Loreto Skills Generator
Geben Sie ein beliebiges YouTube-Video, einen Artikel, ein PDF oder ein Bild in die Loreto-API ein und erhalten Sie produktionsreife Skill-Pakete, komplett mit SKILL.md, Testskripten und Referenz-Stubs.
Dokumentation
loreto-mcp
Your code is your context. Loreto reads your repository's code and git history and finds the four mistakes a coding agent keeps making there:
- Anti-patterns: code your team already added and reverted, and the "never" rules in your decision records. Guard rails block them.
- Abstractions: the modules the rest of the code imports. Your agent reuses them instead of writing a second one.
- Deprecated code: what is retired, what replaced it, and who still calls it. A new call gets a warning.
- Simplification: blocks copied between files, helpers defined many times, modules nothing imports.
Plus the rules nobody wrote down: where code goes, how big a change is, what has to change together. It installs all of it as a harness your coding agent loads, so every pull request it opens reads like your team wrote it.
Then, before your agent writes a line, Gitology tells it whether to build it that way in this repository, with the commits to prove it.
Works with Claude Code, Codex, Muse Code, OpenCode, Hermes, Cursor, DeepSeek Harness, Antigravity and GitHub Copilot.
Start in 30 seconds
claude mcp add loreto -- uvx loreto-mcp
Then tell your agent:
Read github.com/your-org/your-repo with Loreto.
That's it. No account, no key, no config for a public repository (five free reads without an account; a free account lifts the limit). The read is free and shows what it found (anti-patterns, abstractions, deprecated code, duplication) before anything costs money. Say "buy it" and the agent hands you a checkout link; after you pay, it installs the files into your repo itself.
What the harness holds
Written from the repository's own history, with the figure behind every rule:
| File | Claude Code path | What it does |
|---|---|---|
| Root file | CLAUDE.md (or AGENTS.md) | Read on every session: what the repo is and the rules that matter most. Merged between loreto markers; your own file is kept. |
| Conventions skill | .claude/skills/<repo>-conventions/SKILL.md | How a change is made here: where code goes, sizing, naming, testing. |
| Reviewer | .claude/agents/<repo>-conventions-reviewer.md | Checks a change against the repo's own thresholds before a human has to. |
| References | …/references/conventions.md, hotspots.md, coupling.md, lessons-from-reverts.md, anti-patterns.md, code-health.md | The evidence: conventions, the files the work lands in, what moves together, what had to be undone, what not to put back, and what to reuse, retire and simplify. |
| Scripts | …/scripts/guardrails.py, check-change.py, about.py | Python, nothing to install. guardrails.py blocks reverted code and warns on deprecated calls; check-change.py --strict fails a git hook or CI run. |
Each agent gets its own layout (AGENTS.md + .agents/skills/ for Codex and Muse Code, .cursor/rules/ for Cursor, ~/.hermes/skills/ for Hermes). list_agents shows them.
Pricing
Reading a repository and seeing what its harness would hold is free. The harness is $5, or $2 a file (three files cost the same as all of them). No subscription. Each purchase includes 25 questions to the repository.
Install
claude mcp add loreto -- uvx loreto-mcp
Or in any MCP client config:
{
"mcpServers": {
"loreto": { "command": "uvx", "args": ["loreto-mcp"] }
}
}
No API key is needed for public repositories. To keep purchases on your Loreto account, and to read private repositories you have connected to Loreto through GitHub (read-only), add your key from loreto.io/dashboard:
"env": { "LORETO_API_KEY": "lor_..." }
Private repositories
Public repositories need nothing. A private one is read through your own GitHub connection, so Loreto only ever sees what you chose to share:
- Sign in at loreto.io and press the GitHub button. Loreto's GitHub App is read-only, and you pick the repositories it can see (change them any time at github.com/settings/installations).
- Create a key at loreto.io/dashboard/developer and give it to the server:
claude mcp add loreto -e LORETO_API_KEY=lor_... -- uvx loreto-mcp - Ask your agent to read the repository as usual.
If a repository isn't reachable, read_repo says which of these steps is missing instead of failing. Private reads belong to your account and are never shown to anyone else. The repository is cloned read-only on Loreto's server to read its history and code, and the evidence your files are written from (figures from git, plus the first lines of a few of the busiest source files) goes to the model provider that writes them; nothing is published.
Want the code to stay on your machine? check_approach and plan_change run Gitology locally and need no account at all.
Tools
| Tool | Cost | What it does |
|---|---|---|
list_agents | free | The supported agents and where each reads its files. |
read_repo(repo, agent) | free | Reads the history; returns what it says, the files, the prices and a read_id. |
buy_harness(read_id, agent, files?) | $5 / $2 a file | Returns a Stripe checkout link for the person to pay. The agent cannot pay. |
get_harness(path) | — | After payment: waits for the files and installs them into the repository at path. |
ask_repo(question) | included | Why was this reverted? Who knows this code? Answered from the history. |
check_approach(approach, path?) | free, local | Should I build it this way here? Good to go, risky or don't merge, with the evidence and a better route. Runs Gitology. |
plan_change(request, path?) | free, local | A change kit: SPEC.md, and STEPS.md small enough for a small model to build. Runs Gitology. |
A typical session:
You: arm Claude Code with this repo
Agent: (read_repo) Half of the last 400 commits touch 2 files or fewer…
src/api/routes.pyandsrc/api/schema.pychanged together 17 times… The harness is $5. (buy_harness) Here is the checkout link.You: paid
Agent: (get_harness) Armed Claude Code:
~ CLAUDE.md (kept yours, added the Loreto section),+ .claude/skills/…
Gitology: ask before you build
Gitology maps a repository on your machine into a graph of what exists (modules, files, symbols, endpoints, tests, decision records, owners) and how it holds together (imports, changes-with, reverted-by, tested-by), and keeps it current through git hooks. check_approach and plan_change call it:
You: add retries to PaymentClient.capture
Agent: (check_approach) DON'T MERGE. This exact change was made in
823cc78, captured cards twice, and was reverted infac848a; ADR-014 says retries belong in workers. Better route: wrap the call inCaptureWorkerwithwith_backoff. (plan_change) Kit written: 4 steps.
Install it once (Python 3.9+), and the tools find it:
curl -fsSL https://loreto.io/gitology/install.sh | sh
The graph is built locally. Only the verdict and the change kit call a model, they send it the excerpts and history that bear on the question, and the model can be local: set GITOLOGY_MODEL=ollama:<model>, or ANTHROPIC_API_KEY / OPENAI_API_KEY in the MCP server's env. Gitology also runs on its own as a CLI and MCP server: see loreto.io/gitology.
For agents with a wallet: x402
An agent holding USDC on Base can buy without a person or a browser, over x402. The harness is written before anyone pays, and the paid call answers with the files, so a payment settles only on a delivery:
POST https://api.loreto.io/api/v1/harness/prepare {"repo": "...", "agent": "claude-code"} free
GET https://api.loreto.io/api/v1/harness/prepare/{id} poll until "ready" free
POST https://api.loreto.io/api/v1/harness/x402 {"prepare_id": "..."} $5
POST https://api.loreto.io/api/v1/harness/x402/file {"prepare_id": "...", "file": "skill"} $2
Public repositories only. A harness that is not ready yet answers 409 and nothing is charged. Full walkthrough with a Python x402 client: loreto.io/docs#x402. This MCP server does not sign payments.
Changes in 1.2.0
- Every agent the site writes for, including DeepSeek Harness, Antigravity and GitHub Copilot (checked against the live list).
read_repoleads with what it found: anti-patterns it will block, abstractions to reuse, deprecated code still in use, duplication worth simplifying.- A private repository gets the three steps to read it (connect GitHub, create a key, set
LORETO_API_KEY) instead of an error. - Descriptions say what a harness holds now: six references and the skill's guard-rail scripts.
Changes in 1.1.1
check_approach speaks plain words: good to go, risky, don't merge, not sure (from Gitology's new labels).
Changes in 1.1
check_approach and plan_change, through Gitology. Nothing else changed.
Changes in 1.0
loreto-mcp used to wrap Loreto's skill generator and marketplace. Loreto is now about one thing, the harness, and the generator is no longer public. The generate_skills, catalog, marketplace_* and agent_* tools are gone; pin loreto-mcp<1 if you depended on them.