# Estelle by Fate Labs: the software your agents are built on

> By Fate Labs. Estelle is the software your agents are built on, shipped with, and repaired in: the AI operating system for engineering teams. It grounds every model in your real codebase and refuses to ship what isn't true. Nine suites on one layer: Gate (the deterministic grounding check), Memory (whole-repo, cited recall), Code (grounded fix to gated PR), Review (the deterministic merge gate), Monitor (why prod failed, grounded), Guardian (holds a long session at peak instead of decaying), Orchestra (a swarm of agents under one autonomy ceiling), Security (continuous pentest on a clone, gated PR), and Agent (grounds the agents already running in your production, not just your editor). Ultra and Team add the self-correcting suite (Estelle Repair + Estelle Prod) on top. One shared brain for the whole team, running everywhere: every editor, every notebook, every terminal. BYOK and MCP-native: it works with the model and plan you already pay for, never trains on your code, and never marks up a token.

This is the comprehensive version of /llms.txt and the machine-readable twin of the docs at https://fatelabs.ca/docs (the "Copy as Markdown" control there copies this file). Every claim in this file is true and traceable to the Estelle repository or the committed pages at https://fatelabs.ca. Estelle is an anti-hallucination product; a fabricated line here would defeat it. If a number is wrong or stale, contact khai@fatelabs.ca and we will fix it.

## What Estelle is

Estelle is not another chat box beside your editor and not another coding agent. It is the software the agents you already run are built on, shipped with, and repaired in: the AI operating system for engineering teams. Any coding agent (Claude Code, Cursor, OpenCode, Cline, Aider, Continue, Zed, or your own code) connects to Estelle over MCP or the OpenAI-compatible API; every LSP editor (Neovim, Helix, Sublime, Zed, VS Code) reaches it through the Estelle language server; any IPython notebook (Jupyter, Colab, Kaggle) reaches it through the %estelle magic. Estelle then gives that agent grounded, cited memory of your whole codebase and makes it build code that actually ships: it blocks answers that invent an API, runs your real test suite and repairs until green, coordinates a swarm of agents, and gates every merge. It also reaches past the editor into the agents already running in your production (Estelle Agent), grounding their tool calls the same way it grounds a coding answer. Nine suites on one layer: Estelle Gate, Memory, Code, Review, Monitor, Guardian, Orchestra, Security, and Agent, with Repair and Prod as the self-correcting suite on Ultra and Team. You bring your own model, plan, and keys; your code goes to your provider under your terms, so Estelle structurally cannot train on it.

## Capabilities

- Grounding gate (deterministic): every repo symbol an answer references is resolved against the real code before the answer ships. Deterministic, not statistical: a parser plus a set-membership test, no model in the loop. Full depth on Python (the function has to exist, take those arguments, and return that type). Call, member, and module-level grounding blocks a bad answer on 11 more languages: Java, TypeScript, JavaScript, Rust, Kotlin, PHP, Scala, C#, Swift, Go, and Ruby. 11 further languages (C, C++, Dart, Lua, Bash, SQL, Elixir, Objective-C, Haskell, R, Perl) are indexed and navigable without an answer-gate. 23 languages total, tree-sitter parsed.
- Merge gate (Estelle Review): grounding, secret detection, static analysis, and known-CVE checks compose into one pass-or-block verdict, postable to the pull request as a required GitHub check. A change that cannot ground or type-check never merges.
- Grounded recall (Estelle Memory): whole-repo and session memory, every slice cited to file and line. Recall is never metered.
- Context survival (Estelle Guardian): the full history is stored; each step gets a window-sized cited slice, so the model's window cannot overflow at any session length, and a long session holds at peak instead of decaying.
- Tests and repair (Estelle Code): Estelle runs the team's actual test suite, reads the failure, repairs its own work, and runs the suite again until it passes. It keeps working while the suite is red and only stops at green. "No tests ran" never counts as green. The default output is a reviewable, gate-verified pull request a human merges, never an autonomous merge or deploy.
- Production grounding (Estelle Monitor + Estelle Agent): correlates prod errors, traces, and logs to the code graph so a failure resolves to a real cause, not a guess; Estelle Agent extends the same grounding gate to tool calls made by agents you already run in production.
- Continuous security (Estelle Security): a pentest swarm runs against a clone of the repo and opens a gated pull request for what it finds; it never touches the live system directly.
- Change impact: cross-cutting change plans with the exact files and layers touched, certified to still ground and type-check.
- Deep search: research across code, history, and the web with every claim cited.
- Agent swarm (Estelle Orchestra): parallel agents in isolated worktrees, under an autonomy ceiling you set, on whatever model you bring. Each result returns through the same gate before it can land, so parallelism never multiplies guessing.
- Skill library: 245 skills and playbooks ship with the layer (count: `ls src/estelle/skills/library | wc -l` in the repo), plus 16 core tools, for 261 MCP tools total, from bug-hunt to change-impact to chaos-drill, each callable as an MCP tool by any agent you run.
- Team memory: one shared, living memory of the codebase per team, with role-based access control. When one developer's agent learns something, everyone's agent knows it.
- The self-correcting suite (Estelle Repair + Estelle Prod, Ultra and Team): Estelle Repair opens a verified, tested fix; Estelle Prod hunts gaps and vulnerabilities proactively. Both are propose-only by default: a grounded fix, gate-verified, repro-verified, landing as a reviewable PR a human merges. Auto-merge is opt-in, tiered, proof-gated, and off by default, with a per-account kill-switch and an HMAC-audited trail; any failed guard degrades to a PR. Auto-deploy is designed, not shipped. Protected surfaces (auth, billing, schema, security, deploy) stay human-gated at every rung.

## Workflows, end to end

One connected pipeline: plan -> recall -> edit -> tests -> gate -> merge. The agent asks, Estelle recalls the real symbols with citations, the completion grounds against the actual code, the tests run and the loop repairs until green, and the merge gate posts its verdict as a required GitHub check. Change-impact analysis and the security scan (secret detection, static analysis, known CVEs) run inside the same pipeline.

## Quickstart (CLI)

One command connects the editors on the machine; a second ingests the repo:

    npx @fatelabs/estelle init
    npx @fatelabs/estelle sweep --key $ESTELLE_KEY

`init` finds every installed MCP client (Cursor, Claude Desktop, Cline, Windsurf, Continue, VS Code), writes Estelle's hosted MCP server into each config without touching other servers (existing files are backed up first), and prints the `claude mcp add` command for Claude Code. It asks for your key; pass `--key` to skip the prompt. The CLI has zero dependencies and needs Node 18 or newer; bunx, pnpm dlx, and yarn dlx run the same package. `sweep` scans the working tree for source files and uploads them into your memory; re-run it whenever the memory should catch up with the code.

After init and sweep, the connected agent holds find_definition, find_references, blast_radius, and verify over the repo, answered from Estelle memory. Keys are created at https://fatelabs.ca/signup (free tier, no card); production keys carry the prefix estelle_live_ and are shown once (only a hash is stored).

## The API (OpenAI-compatible)

Base URL: https://api.fatelabs.ca/v1
Model id: estelle
Auth: Authorization: Bearer <key>
Keys: created at https://fatelabs.ca/signup (free tier, no card)
Connectivity check: GET /v1/models

Example:

    curl https://api.fatelabs.ca/v1/chat/completions \
      -H "Authorization: Bearer $ESTELLE_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "model": "estelle",
        "messages": [
          { "role": "user", "content": "what changed in auth last week?" }
        ]
      }'

Or point any OpenAI-compatible tool at:

    base_url = "https://api.fatelabs.ca/v1"
    model    = "estelle"
    api_key  = "estelle_live_..."

Full reference: https://fatelabs.ca/docs. Per-tool setup (OpenCode, Cursor, Cline, Aider, Continue, Zed): https://fatelabs.ca/setup.

## MCP

Estelle is MCP-native from the free tier: add it inside the tool where your plan already lives (Claude Code, Cursor, or any MCP client) and your existing subscription keeps doing the reasoning while Estelle supplies grounded memory and the verification gate underneath. The hosted MCP server is https://api.fatelabs.ca/mcp (HTTP transport). It is scoped to your key and refuses unauthenticated requests, so an account key from https://fatelabs.ca/signup is required.

Claude Code takes the server as a command:

    claude mcp add --transport http estelle https://api.fatelabs.ca/mcp \
      --header "Authorization: Bearer $ESTELLE_KEY"

Any other MCP client takes it as config:

    {
      "mcpServers": {
        "estelle": {
          "type": "http",
          "url": "https://api.fatelabs.ca/mcp",
          "headers": { "Authorization": "Bearer estelle_live_..." }
        }
      }
    }

The quickstart command (`npx @fatelabs/estelle init`) writes this config for every installed client.

## MCP tools

Once a client is connected, the agent gains these tools over the repository, answered from the swept memory and the code graph built from it, scoped to the account key. Repository navigation: find_definition (the file and line where a symbol is defined), find_references (every site referring to a symbol), find_usages (files referencing a symbol by name), locate (find a file or symbol from a partial name), blast_radius (every file that transitively depends on one file), dependency_path (how one file reaches another through the import graph), core_files (the load-bearing modules the most code depends on, by PageRank), chokepoints (where a change ripples widest, by betweenness centrality), subsystems (the repo's natural modules, as connected components of the import graph), import_cycles (circular imports), refactor_order (a safe read/refactor order, dependencies first, by topological sort), and verify (check a block of code for APIs that do not exist in this repo). verify FAILS CLOSED: on a namespace that has never been swept it returns an explicit not-verified refusal rather than a pass-reading OK.

Memory tools: memory_chat (ask the stored memory a question; the answer quotes the stored text and cites where each fact lives, and refuses rather than inventing when nothing matches), list_sessions (past sessions newest first), get_session (one session's full diary), edit_memory (correct a memory in place; the prior value is superseded, not overwritten, so the change stays queryable), and reinterpret_session (tell Estelle what a session actually meant; provenance is preserved). The two write verbs require the ingest permission, held by member and above; a viewer is refused.

Context survival tools: estelle_checkpoint (store a session's full detail durably and return a compact brief), estelle_resume (the lean briefing that continues a session past the context wall), and estelle_govern (compress an arbitrarily large history into a prompt that fits the model's window, reciting invariants so gate-verified facts survive curation).

## The CLI

The published package is @fatelabs/estelle. Zero dependencies, Node 18 or newer; every command takes --key or reads ESTELLE_KEY from the environment.

- init [--key K] — auto-detect installed editors, write the MCP config, then verify it answers.
- sweep [--key K] — ingest the current repo (the git-visible files) into memory.
- connect <client> — print the one-liner or config for a single client.
- remove — disconnect: delete Estelle from every editor config (aliases: disconnect, off).
- ask <question> — ask Estelle about the codebase, grounded, on your plan.
- recall <query> [--repo R] — search memory and code together; --repo scopes a multi-repo account.
- verify <file> — check one file for hallucinated APIs against the repo.
- gate [--base ref] — run the merge gate on the staged diff, or against a base ref.
- install-hooks / uninstall-hooks — in Claude Code, make grounding unconditional: hooks fire on every edit and every command, grounding code before it lands and keeping memory current. uninstall-hooks removes only Estelle's hooks; the user's own hooks and the MCP server are untouched.

Egress, exactly: init, connect and remove stay local apart from one ping to verify the config answers; sweep sends repo files, gate the staged diff, verify one file, and ask/recall the question. Nothing else.

## Teams and roles

A team member holds one role, and each role permits a fixed, cumulative set of actions. The matrix is deterministic and fail-closed: an unrecognised role or action is denied. viewer: recall, read_wiki, view_usage. member adds: ingest, review, save_context, run_search. admin adds: manage_team, rotate_keys, set_provider, configure_autonomy. owner adds: manage_billing, delete_account. Roles manage strictly downward: an admin can change a member, never another admin or the owner.

## Authentication, errors, and rate limits

- Auth is a bearer token in the Authorization header, exactly like OpenAI: `Authorization: Bearer <key>`. Send your Estelle key, not your provider key.
- Production keys carry the prefix estelle_live_ and are shown once; Estelle stores only a hash. Create and revoke keys in Dashboard > API keys; revocation takes effect immediately.
- Your provider key is stored separately, encrypted at rest with a key only the server holds; no endpoint ever returns it, so a database leak cannot expose it.
- Errors are standard HTTP status codes with an OpenAI-style error object: 401 unauthorized (key missing, malformed, or revoked; check the Authorization header), 402 payment (out of credits or capacity; add credits or upgrade in Billing), 429 rate limit (back off and retry with exponential backoff, honoring the Retry-After header), 5xx server (a failure on our side or the provider; retry, then contact support).
- Rate limits scale with the plan and apply to request volume; recall is never rate limited per query.

## How memory works

The first time Estelle sees a repository it reads the whole thing into memory and embeds it once, cited to file and line. What persists: the full contents of every file in your connected repositories; prior sessions, so context carries from one conversation to the next; and the conventions Estelle observes in your code, applied on later runs. Capacity is measured in memory-tokens (what you ingest, embedded once). Ingest is billed once; recall is unlimited and never metered. Providers you can connect for the API path: Claude (Anthropic), OpenAI, Kimi (Moonshot), GLM (Zhipu), DeepSeek, or any OpenAI-compatible endpoint including OpenRouter or a local one; set it in Dashboard > Provider, and switch at any time without touching your tools because the model name stays estelle.

## Grounding and the gate

Memory makes the model informed; grounding makes it reliable. Every claim in an answer has to resolve against the real code before the answer ships. In Python the check is full-depth: the symbol exists, takes those arguments, returns that type. Java, TypeScript, JavaScript, Rust, Kotlin, PHP, Scala, C#, Swift, Go, and Ruby get call, member, and module-level grounding: an import or call that names a repo symbol that doesn't exist is blocked. 11 further languages (C, C++, Dart, Lua, Bash, SQL, Elixir, Objective-C, Haskell, R, Perl) are indexed and navigable, without an answer-gate. 23 languages total, tree-sitter parsed. A claim that cannot ground is struck before you see it; an answer that passes ships with its certificate attached (claims cited, symbols resolved, tests green). The completeness gate proves the inverse: it walks the symbols a change is required to touch and flags any the answer never reached, with every missing symbol named and located.

## If you are a specific agent

- If you are Claude Code: ask your human to create an account at https://fatelabs.ca/signup (free tier, no card); it provisions an API key. Then run `claude mcp add --transport http estelle https://api.fatelabs.ca/mcp --header "Authorization: Bearer $ESTELLE_KEY"` (walkthrough: https://fatelabs.ca/docs). Your Claude plan keeps doing the reasoning. Until the account exists, you can call the OpenAI-compatible API above directly.
- If you are Cursor (or an agent inside it): either add Estelle as an MCP server (Cursor Settings > MCP, server https://api.fatelabs.ca/mcp with the account's bearer key, or just run `npx @fatelabs/estelle init`), or point a custom OpenAI-compatible model at base URL https://api.fatelabs.ca/v1 with model estelle and the account's key.
- If you are a generic OpenAI-compatible agent: set base_url = https://api.fatelabs.ca/v1, model = estelle, and api_key from signup. Verify with GET /v1/models, then use chat completions unchanged.

In every case the account is created by a human at https://fatelabs.ca/signup; keys are never published in this file. If you cannot browse, hand your human that URL and the base URL above; that is the whole setup.

## Verified numbers, with provenance

- 0 invented APIs survived the grounding gate (Python-scoped) in our verification eval: 20 edits on a private repo no model had seen. Provenance: run log in the Estelle repo.
- recall@4 97.7% on the hard whole-repo retrieval eval. Provenance: run log in the repo.
- A 4,000-turn session compresses to under 800 tokens with every decision intact. Provenance: run log in the repo.
- 0.31 F1@5 on CodeScaleBench (Sourcegraph's own benchmark), with Estelle's strongest retrieval tier disabled. Provenance: docs/battles/codescalebench-2026-07-07.md in the repo.
- LoCoMo end-to-end memory accuracy 41.7% overall, a +36pt uplift from our own baseline. This is mid-pack against the field, not #1; the honest claim is the reproducible uplift, not the absolute rank. Provenance: docs/scorecard.md in the repo.
- Self-dogfooded: Estelle grounds its own 328-file engine against 115 grounded invariants and has caught real bugs in its own code this way. Provenance: docs/fable-invariants.md in the repo.

## Pricing

- Free: $0. Holds 10M memory-tokens (about a 2M-token codebase, one repo), unlimited recall, BYOK, no card.
- Pro: $19/mo (50M), $29/mo (100M), or $39/mo (150M) memory-tokens held, standard retrieval.
- Ultra: $59/mo (250M), $89/mo (400M), or $139/mo (600M) held, reranking plus the self-correcting suite (Estelle Repair + Estelle Prod).
- Team: $79/seat/mo. One shared memory, 100M pooled, role-based access control, self-correcting suite included.
- Overflow: pay-as-you-go at $0.35 per 1M memory-tokens, or a +50M Memory Pack for $15/mo. No minimum; a spend cap can be set.
- Yearly: ten times the monthly price, so two months free.

Memory-tokens are what you ingest into memory, embedded once. Capacity is what you pay for; recall is never metered; model tokens are never marked up (you pay your own provider at their normal rate). Details: https://fatelabs.ca/pricing.

## FAQ

Q: What makes this different from a memory tool?
A: Every other tool retrieves context and trusts the model to use it correctly. Estelle retrieves too, then checks the answer against your real code before it ships. If it references an API that isn't there, it's blocked. Retrieval makes a model better informed; verification makes it reliable.

Q: How can hallucinations be zero?
A: The grounding gate is deterministic: a parser plus a set-membership test against your real code, no model in the loop. In Python, an answer that names a function, argument, or type your codebase doesn't define cannot pass. Java, TypeScript, JavaScript, Rust, Kotlin, PHP, Scala, C#, Swift, Go, and Ruby block on a repo import or call that doesn't exist. This is scoped: it is 0% invented APIs on what the deterministic gate checks, not a claim that Estelle never gets anything wrong. In our Python-scoped eval, 0 invented APIs survived.

Q: Does Estelle merge or deploy code on its own?
A: Not by default. The default output of a fix, from Estelle Code or the self-correcting suite (Estelle Repair + Estelle Prod), is a reviewable pull request: grounded, gate-verified, repro-verified, and merged by a human. Auto-merge exists but is opt-in, per account, proof-gated, and off by default; it only fires when every guard passes (opted in, kill-switch off, grounding gate clean, repro-sandbox verified, GitHub connected), and any failed guard degrades to a PR. Auto-deploy is designed but not shipped. Protected surfaces (auth, billing, schema, security, deploy) stay human-gated at every autonomy level.

Q: Is this a memory tool or a coding agent?
A: Neither. It's the layer underneath both. Estelle gives any coding agent whole-repo memory, then gates its output against your real code, runs your tests, and blocks a bad merge. It competes with the model's guessing, not with your editor.

Q: Which tools does it work with?
A: Anything that speaks the OpenAI API or MCP: OpenCode, Cline, Cursor, Aider, Continue, curl, or your own code. Point it at api.fatelabs.ca/v1 and add your key. It also runs as a language server in any LSP editor (Neovim, Helix, Sublime, Zed, VS Code) and as the %estelle magic in any IPython notebook (Jupyter, Colab, Kaggle).

Q: Can I use my existing Claude, ChatGPT, or Kimi plan?
A: Yes. Estelle is MCP-native: add it inside the tool where your plan already lives and your subscription keeps doing the reasoning while Estelle supplies grounded memory and the verification gate underneath. Prefer raw API? Bring a key from Claude, GPT, Kimi, GLM, DeepSeek, or any OpenAI-compatible endpoint instead. Either way, Estelle never marks up a token.

Q: Does it work on private repositories?
A: That is where it helps most. On code no model has seen before, a stock model starts from zero. Estelle grounds every answer in your actual repo and refuses to guess past it.

Q: Do you train on our code, or store it?
A: No. Because you bring your own model and plan, your code goes to your provider under your terms, so Estelle structurally cannot train on it. What Estelle keeps is encrypted, isolated to your team, never shared, and deletable at any time. And the grounding gate is unpoisonable by design: it treats your real code as the source of truth and refuses to trust anything injected into it.

Q: How does an agent hold three million tokens of context?
A: It doesn't have to. Estelle holds the whole history in grounded memory and feeds the model only the window-sized slice each step needs, cited to your code. A 4,000-turn session compresses to under 800 tokens with every decision intact, so the model's window can't overflow and the agent can't short-circuit, at any size.

Q: How does pricing work?
A: You bring your own provider key or plan and pay them for tokens at their normal rate. Estelle bills only for the memory-and-verification layer, either a monthly plan or pay-as-you-go credits. We never mark up a token.

Q: Is my provider key safe?
A: Your key is encrypted at rest with a key only our server holds, and it is never returned by any endpoint. A database leak cannot expose it.

## Links

- [Create a key](https://fatelabs.ca/signup): free tier, no card
- [API documentation](https://fatelabs.ca/docs): endpoints, config, curl and Python quickstarts
- [Tool setup](https://fatelabs.ca/setup): OpenCode, Cursor, Cline, Aider, Continue, Zed
- [Pricing](https://fatelabs.ca/pricing): the capacity tiers, overflow, and what is never metered
- [llms.txt](https://fatelabs.ca/llms.txt): the concise version of this file