Overmind trains models you own, on data only you have. Point it at your repo and it turns production traces — or any dataset you bring — into a fine-tuned model, benchmarked against the model you run today and served on one API, with no ML infrastructure to build. The weights are yours to download, retrain or roll back. It starts by reading your code into a context graph of your agent, so it arrives already knowing what your agents do, and the evals, datasets and training are built for your agent rather than a generic recipe.
Every stage is available from the Console, the overmind CLI, the REST API, and an MCP server for Cursor, Claude Code, OpenCode and Codex. Use the hosted version at console.overmindlab.ai or run it yourself with Docker Compose.
| Context graph | overmind sync scans your repo and builds a graph of your agent: each capability, its prompt, its tools, its inputs and outputs, and the tasks its code can perform. |
| Observability | Traces arrive over OpenTelemetry (overmind.init() instruments the SDKs you already use; any OTel exporter works), are matched to the part of the agent that produced them, and are scored in real time, with the reasoning behind each score. |
| Data Workshop | A data agent that automates turning your traces or uploaded files into training and eval datasets, in a notebook where every step is versioned and can be edited or re-run. Every example traces back to the run it came from. |
| Evaluations | Evaluators are generated from the context graph for each capability — LLM judges, trajectory checks, deterministic and statistical tests — and run live on production traces. |
| Optimiser | Run experiments on your agent in its own environment: variants of prompts, tool descriptions, control flow and model are run against a dataset and scored; the best comes back as a git diff. |
| Training | LoRA, QLoRA or full fine-tunes of open-weight models on your data. Overmind recommends the base models suited to the task, estimates cost and duration before you commit, and benchmarks the result against the model you run in production on the same eval set. |
| Inference | Trained and frontier models on one OpenAI-compatible API; a copy-paste prompt switches your agent to the new model. Download the weights and run them anywhere. |
Sign up at console.overmindlab.ai, pick your coding agent on Get started — Cursor, Claude Code, OpenCode or Codex — and paste the onboarding prompt into it with your agent's repo open. It installs overmind, runs overmind init and overmind sync, and builds the context graph. From then on everything is a /overmind command in the same chat:
| Command | What it does |
|---|---|
/overmind ensure-tracing |
Inspect traces and instrument the agent |
/overmind dataset |
Build, clean, upload or export a dataset |
/overmind finetune |
Fine-tune, deploy and smoke-test a model |
/overmind optimise |
Run prompt and code optimisation |
/overmind backtest |
Compare models against the agent's own traces |
Self-hosting keeps traces and training data inside your own network. The hosted and self-hosted stacks are the same code.
git clone https://github.com/overmind-core/overmind.git && cd overmind
cp .env.example .env # OpenRouter, S3, a training backend (Modal or Baseten), an LLM key for the Data Workshop agent
docker compose up -d # Postgres, Redis, API on :8000, Celery workers, beat, Grafana on :3001
cd frontend && bun install && bun run dev # Console on :5173On first boot the API runs migrations and seeds the built-in evaluators; Swagger is at /api/docs/. docker compose exec -T api python manage.py shell < seed.py loads a full demo workspace.
What the API needs to boot
The API will not start without these. .env.example documents every other key.
| Group | Variables |
|---|---|
| Object storage | AWS_BUCKET_NAME, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY — checkpoint archive |
| Training backend | FINETUNING_BACKEND=baseten + BASETEN_API_KEY, or FINETUNING_BACKEND=modal + MODAL_TOKEN_ID + MODAL_TOKEN_SECRET |
| Serving | INFERENCE_API_URL — the Modal vLLM endpoint printed by modal deploy |
Two keys gate features rather than boot: OPENROUTER_API_KEY for judges, evals and every routed model call, and one LLM key for the Data Workshop agent — it uses the first of CURSOR_API_KEY, OPENROUTER_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY or GEMINI_API_KEY it finds. Without STRIPE_SECRET_KEY, usage is metered and shown with no remaining-credit cap.
pip install "overmind[tracing]"
export OVERMIND_API_KEY=ovr_… # project key from Console → Settings; add OVERMIND_API_URL for self-hostimport overmind
overmind.init(
service_name="support-agent", capability_id="<capability-uuid>", providers="auto"
)
@overmind.tool()
def search(query: str) -> list[dict]: ...
def handle(request: dict, session_id: str) -> dict:
with overmind.run(
"support-run", intent=request["question"], conversation_id=session_id
) as run:
answer = agent(request)
run.deliver(answer) # the final output that gets scored
return answerproviders="auto" instruments the LLM SDKs you already use over OpenTelemetry; without a key, tracing is off and nothing breaks. Any OTel exporter can POST /api/v1/traces instead, and existing traces in Langfuse, LangSmith, Braintrust or Galileo can be synced through a connector. Open Observability → Task executions to see the trace and its score.
Overmind ships an MCP server at /api/mcp/: 32 tools, 14 resources and 11 prompts covering everything the Console can do, scoped to one project by its API key. Every tool declares what it costs to run (free, compute, llm, gpu) and none can delete anything. overmind init --ide <cursor|claude|opencode|codex> writes the config for you, or by hand:
Cursor — .cursor/mcp.json
{
"mcpServers": {
"overmind": {
"url": "https://api.overmindlab.ai/api/mcp/",
"headers": { "X-Api-Key": "ovr_…" }
}
}
}Claude Code
claude mcp add --transport http overmind https://api.overmindlab.ai/api/mcp/ --header "X-Api-Key: ovr_…"OpenCode — opencode.json
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"overmind": {
"type": "remote",
"url": "https://api.overmindlab.ai/api/mcp/",
"enabled": true,
"headers": { "X-Api-Key": "ovr_…" }
}
}
}Codex — .codex/config.toml
[mcp_servers.overmind]
url = "https://api.overmindlab.ai/api/mcp/"
http_headers = { "X-Api-Key" = "ovr_…" }What the tools cover
| Domain | Tools |
|---|---|
| Observability | inspect_capability_health, query_failures, query_traces, query_task_executions, get_job |
| Datasets | list_datasets, inspect_dataset, query_dataset, create_dataset_from_traces, message_dataset_agent, run_dataset |
| Evaluations | check_evaluation_readiness, upsert_evaluator, run_evaluation, compare_evaluations, annotate_evaluation_sample |
| Training | check_finetune_readiness, estimate_finetune, start_finetune, retry_deployment, set_active_model, run_inference, get_model_swap_prompt |
| Optimiser | check_optimizer_readiness, start_optimizer, inspect_optimizer_result |
| Connectors | inspect_connectors, configure_connector, sync_connector |
| Instrumentation | get_instrumentation_plan, verify_instrumentation |
| Catalog | get_model_catalog |
Prompts such as investigate-capability, finetune-capability and ship-model chain the tools into complete workflows.
For a self-hosted instance, replace the host with your API URL (http://localhost:8000 locally). Keys are written to git-ignored files only; overmind sync will not write a key into a tracked file.
All documentation lives at docs.overmindlab.ai:
| Section | What's covered |
|---|---|
| Quickstart | Sign up, paste one prompt into your coding agent, run /overmind commands |
| Agent & Capabilities | The context graph: repo scans, capabilities, tasks, telemetry attribution |
| Observability | OTLP ingest, span model, attribute mapping, the trace explorer |
| Python SDK | init(), auto-instrumentation, run(), decorators, tasks and capabilities |
| Trace scoring | How a production trace becomes scored task executions and session scores |
| Datasets | Source, cells, versions, the data agent, trace-to-dataset |
| Eval | Evaluator kinds, eval sets, live scoring, eval runs |
| Optimisers | The optimisation loop, the local executioner, the winning diff |
| Training | Dataset validation, model recommendations, loss curves, the benchmark |
| Inference | Serving lifecycle and /api/v1/chat/completions |
| REST API | Auth, endpoint map, conventions, Swagger |
| Projects & Administration | Projects, API keys, connectors, jobs, billing |
| Glossary | Terms as they appear in the Console and the API |
overbae/ Django 6 API — api/ (DRF, OTLP, OpenAI-compatible), models/, services/ (eval, datasets, mcp, sft_assets), tasks/ (Celery), modal/ (GPU workers)
frontend/ React 19 Console — src/openapi/ is generated by `make generate_api_client`, never hand-edited
overmind/ Python SDK + CLI, published to PyPI as `overmind`; skills/overmind/ is the /overmind skill
tests/ pytest — `make test`
AGENTS.md how we work, for humans and coding agents; .claude/skills/ documents each subsystem
Backend is uv (make test, make lint-backend, make check-migrations); frontend is Bun (bun run typecheck, bun run lint, bun run test); SDK is make -C overmind test. Training and serving run on Modal or Baseten (FINETUNING_BACKEND); inference is vLLM behind /api/v1/chat/completions.
Open an issue, or a PR from a feature branch using .github/PULL_REQUEST_TEMPLATE.md — main is protected and AGENTS.md describes how we work. Questions go to the Discord.
The SDK and CLI send anonymous usage analytics to PostHog — one cli.invoked event per CLI run and sdk_init on library use; never prompts, trace contents, keys or dataset contents. Opt out with OVERMIND_ANALYTICS_ENABLED=false or DO_NOT_TRACK=1; analytics is also off when CI is set. Your traces go only to your own project.
