the layer your agent asks before it reads
Your agent askswho calls it first.
One index of your repository, and everything that reads from it — the call graph, the decisions, and whichever model still has allowance to do the work.
Indexing checkout-service before I touch anything.
tab to expand
Thought for 0.7s
Another session is already open in workers/. I'll coordinate before overlapping.
Thought for 1.8s
Thought for 2.2s
Payments split across intent.py, reconcile.py and a nightly retry. Only the first two are mine.
Thought for 1.1s
Starting from the graph so the settlement change stays on the call sites that actually exist.
Thought for 4.1s
A capture guarded by a window constant, three call sites, and a warning somebody already anchored on the symbol.
Thought for 2.6s
The reconciler compares against the old constant. It would refuse exactly what intent.py is about to accept.
Two files opened, not the eleven a directory walk would have cost.
The foundation
Four things a file read can never give it.
An agent that cannot ask a precise question has no choice but to open a whole file and hope. Everything below follows from removing that constraint.
Context window
What enters the window is chosen, not swept in
Tool output crowds out the task. Asking for one symbol's wiring returns the same knowledge at a fraction of the window, so what is left holds the problem.
Graph reduction
Many reads collapse into one asked question
A directory walk offers every line in the repository. The graph returns the symbol, its callers and the decision on it — and marks which edges it proved.
Bounded output
Every answer declares its ceiling first
A wide question about a hot symbol cannot quietly return a hundred thousand tokens. The shape of the reply is decided before the bytes are.
Local saves
Uncommitted work survives the crash
The tree is snapshotted before every tool call — not by git, and never touching it. A killed process or an agent that overreached is one restore away.
One parse. Everything downstream reads from it.
Your agent
asks in symbols
Other models
read the same answers
The notes
anchor to the graph
The checks
run against it
Tree-sitter parses each file once into a SQLite index that lives inside your repository. No daemon to run, no embeddings to build, no key to paste, and nothing that phones anywhere.
Start
It begins with the task, not the tree
Give it the sentence you were given. It returns the symbols that task touches, what is already uncommitted, and any decision a previous session anchored there — before a single file is opened.
Reach
It finds the caller nobody remembers
Extending anything is safe right up until the one call site that was never in your head. The blast radius comes back before you plan, not after the branch turns red.
Read
It reads only the source it named
Numbered the way a file read is numbered, so the edit that follows needs no second look. Past ninety lines it arrives as its shape first, with the exact range to ask for.
Change
It changes one symbol, not one file
Scoped to the symbol it named. An ambiguous or missing match is refused, the tree is snapshotted first, and anything that stops parsing is rolled back on the spot.
Starting from the task rather than the directory.
Thought for 2.1s
A warning is already attached here: the provider settles late, so refusing is a double charge.
Durable memory
A conclusion outlives the session that reached it.
session one
It learns the provider settles late
it writes it down
Anchored to the symbol, not a line
the limit
The session ends mid-turn
session two
A fresh agent opens with the finding
1,027
tokens to rebuild the task in a fresh window — against the 382,043 the dead session spent on its final turn alone. The transcript is a recording; what agix keeps is the conclusion, attached to the symbol that has it.
The plane around it
Or hand the work to whoever still has room.
Provider routing
Allowance runs out one provider at a time, and always mid-task. agix knows which models are installed, signed in and still have headroom, and moves the work before you are stopped.
No vendor SDK
each is a CLI you already signed into, driven as a process
No single point
an outage takes out one row, not the tool
68%12%91%100%Delegation with a receipt
A slice goes to a named model and comes back accounted for. A delegate that ignored the index and read whole files anyway shows up here as a number rather than a feeling.
4m 12s$0.04310+213 across 4 files1Two models on one hard call
Some decisions are worth a second opinion before any code moves. Both plan it together, split it, and report which half each took — and they can message each other mid-task without either stopping.
Parallel
four agents on four slices, none blocking you
Coordinated
live presence, so two never edit the same symbol
Another session is already in reconcile.py.
Agreed. I'll take the nightly retry as well.
It answers about the page, too
The same binary drives a real browser and returns text instead of screenshots — controls you can act on by reference, console errors, failed requests, and the value the page actually computed.
Layout grading
contrast, tap size and line length, measured
Isolated audits
attack a copy of a project, never the original
It shows Total £132.00 — VAT applied twice.
40 capabilities, one index behind all of them.
Each declares its own ceiling before it answers, so a wide question can never quietly fill a context window — and each returns plain text, so anything that can run a process can read it.
Task context
the symbols a task touches, what is uncommitted, and the decisions already anchored there
Edit targeting
where a change lands and everything wired to it, in one answer
Symbol wiring
definition, callers, callees and confidence for any name in the repository
Scoped source
the body of one symbol, numbered, instead of the file that contains it
Blast radius
every caller a change reaches, direct and transitive, before you plan it
Structural search
text hits reported by the function that contains them
Cross-language reach
where a call ends up in another language, and the path it took
Stack-trace mapping
a file and line from a crash resolved to the symbol that owns it
Repository shape
size, languages, hot directories and the symbols everything hangs off
No service
The index is a file in your repository. Delete it and nothing is owed to anyone.
No configuration
One command indexes a repository. There is no file to write first and no key to paste.
Nothing leaves
Parsing happens on your machine. No daemon, no embeddings, no network call.
The worst day
The session ends at that line.
A usage limit arrives without warning, mid-turn, and there is no later turn in which to save anything. Whatever the next agent gets had to be written before it happened — which is why the checkpoint cannot ride on the end of a turn.
0
turns in the session that motivated this
0
tokens ingested, never once compacted
0
tokens on its final turn alone
0
tokens to rebuild the same task after
Why it fires before every tool call
A Stop hook runs once per completed turn — and the turn a limit kills is, by definition, the turn that never completes. Measured by instrumenting real hooks and then killing a real session mid-call.
| measured | PreToolUse | Stop |
|---|---|---|
| 5 sequential calls | 5 | 1 |
| killed mid-turn | 2 | 0 |
And it costs nothing to carry
Ten to twenty milliseconds, before every tool call, printing nothing at all. A hook that wrote to stdout would inject itself into the conversation and tax every remaining turn.
This is deliberately not the problem auto-compact solves. Compaction fires on window pressure; your allowance burns continuously, long before the window is anywhere near full.
$ agix continue
Index your first repository tonight.
It runs where you already work. Nothing is uploaded, and the index sits in the repository — delete it and nothing is owed to anyone.
cargo install --path .one local binary — no daemon, no key, no account
agix init --globalteaches your agent CLIs to reach for it, once, for every repo
agix context "the task"the first query in a repository builds its index
Already running Claude Code or Codex? Then you are done. agix installs a discovery hook that fires before the first decision of a session, rather than a skill that waits to be chosen — which, measured across four runs here, it never was.