The software your agents are built on.

Deterministic, not a second opinion. A parser and a set-membership test against your real code, with no model in the loop, so the same diff always gets the same verdict.

Every claim resolves to a file and line. A claim that passes carries its citation. A claim that resolves to nothing is refused rather than softened into a maybe.

It runs where merges happen. The check arrives on the pull request, so an invented API is stopped before a reviewer spends attention on it.

Code-native, not a chat log. Recall is addressed by file and line, so an answer points at the code it came from instead of paraphrasing a conversation about it.

Gated by role, never leaking across. Each repo and each team keeps its own namespace, and a question scoped to one never resolves against another.

The reasons live outside the diff. It indexes the threads and the issues where decisions were actually made, because the code alone cannot tell you why.

Real edits, not a suggestion box. It works in the actual repo on a branch, so what you review is the change itself rather than a snippet to transcribe by hand.

Every change carries its citation. Each edit resolves to the code it was derived from, and the gate refuses the ones that do not.

A reviewable pull request by default. The base plan is a sandbox write and an open PR. A human merges it.

Grounded in the repo, not the diff. A change that breaks a caller three files away is found because the caller was read, not because the pattern looked risky.

Adversarially cross-checked. Findings are put to an independent pass that tries to refute them, so what posts is what survived.

Cited comments, on the line. Every finding arrives attached to the code it concerns, with the evidence that produced it.

From a failure to a file. It follows a production error back through the trace to the exact line, instead of stopping at the service that happened to report it.

It says where, not just what. An alert names the code path that broke and the change that introduced it, so triage starts at the cause.

The fix goes through the gate. A repair is checked like any other change and arrives as a pull request, not as a silent write to production.

A ceiling on the context, enforced every turn. The working set is fitted to a token budget derived from the model's own window, so a session that has run all day sends a prompt the size of the one that started it.

Curated context, not a bigger window. What the model already tried is distilled into short lessons and kept when the raw trace is cut, so a dead end is not re-read at length and not walked twice either.

Model-agnostic, on your keys. It sits under whichever model you already pay for, and never asks you to switch to keep the benefit.

Parallel work, properly isolated. Each agent gets its own git worktree, so two of them editing the same file cannot corrupt each other's run.

Routed by cost and by difficulty. Cheap work goes to a cheap model and hard work escalates, across every provider key you have already bought.

One autonomy ceiling for every lane. All of them merge through the same gate, and no lane can raise its own permissions to get around it.

It runs against a clone, never production. The attack surface is a mirrored sandbox, so a probe can be as aggressive as it needs to be without reaching a customer.

Finds it, then proves it. A finding carries the request that reproduced it. The ones that cannot be reproduced are not filed as findings.

Arrives as a gated pull request. The fix comes with its repro attached and waits for a human, like every other change Estelle proposes.

MCP, so it works where you already are. Claude Code, Cursor and any other MCP client pick it up without rewriting the agent around it.

It grounds the tool call, not just the prose. Claims and tool arguments are checked against your real code before the agent is allowed to act on them.

Your keys, your repo. Estelle is the infrastructure around the model rather than another model, and it never marks up what you already pay for.