Steer your agent swarms by every command they run.
Your agents act in code, for days, many at once. Olki reads every line as it runs and acts on it: it compacts at the right moment, stops a rogue chain, checks every handover, and turns repeated work into circuits it runs itself. Without touching your model's weights.
#Your agents act in code, for days, many at once.
They rarely run one command. They run pipes, chains and scripts, thousands a day, and hand work to helpers.
A log of tool calls keeps each of those lines as one long string. Nobody can steer by that.
#Olki reads every line as it runs.
For every line, Olki answers three questions: what it costs, whether it is safe, and whether it moves your task forward.
Each line comes apart into steps, each with its kind, its program and what it touches, in 31 ms. Pick a line and watch Olki read it. Then change where it runs, or whether Olki only watches, and see the verdict change.
Run on , with Olki , this line is
Olki also records what no line declares: 87 in 100 network connections were seen only as they ran.
#Follow one agent for ten days.
Everything from here on is one Claude Code session: 785 prompts, 155 helper agents, 183 commits, $2,646 at list price.
Olki keeps it as one record and lays it out day by day: what was read, changed and checked, and each time the agent's memory was squeezed.
#It tells tokenmaxxing from efficient engineering.
Give two engineers the same agent and the same task. One burns tokens, the other runs it well. Olki reads every line, so it can tell them apart.
The first leaves the harness on its defaults, reads the same files again and again, and merges changes without a check. The second checks each change, hands the reading to helpers, and keeps the memory lean. Yield scores each session from 0 to 100 against your own earlier ones, on seven plain measures. You choose what matters: ship, careful or lean.
Underneath the score is the loop every change should go round: read, change, check, merge. Each skipped step costs you, and Olki sees every skip.
check the 119 changes no check covered, then score the next run
#It finds when to compact, and can do it for you.
Olki finds the best point and the best interval to compact for your work, and can compact at them for you. Here, that would have cut the bill by a fifth.
As an agent works, its memory fills up, and the harness squeezes it when it is full: 77 times in these ten days, each time past half a million tokens.
Compacting at the wrong time also causes mistakes. After each squeeze the agent forgets some of what it learned, and late in the run it made the same mistakes again.
compact at a natural break, not at the cliff
#It stops a rogue chain.
Attacks happen in steps: the agent reads text from the internet, picks up a key, then sends data out. Olki sees each step, and what ties one to the next.
In this session, 3 commands read from the internet and asked for a key, and 5 read a sensitive place and reached another computer. Olki was only watching, so they all ran. Turn on blocking, and Olki stops the next step.
A red line joins two steps only where one command did both. Point at a mark to see what ran.
It also maps what was in reach, which programs connected out, and where the data went.
Bars are bytes sent, to scale. Point at a program or a host to follow its lines. Keys join the programs by a bracket, because the record cannot say which program asked.
And it says what to do first, with the commands to open.
switch one rule from watching to blocking
#It checks every handover.
When work passes to a new agent, another harness or another model, the new session asks the record what happened, and Olki checks each thing it claims.
Olki gives them one way to hand over, instead of reading the whole transcript. Ten sessions picked up this one, 24 times: 296 of their 312 claims were right, and Olki flagged the 16 that were not.
hand work over by the record
#Your agents get a language of their own.
In Olki's language, work becomes a circuit: a small, named program that says up front what it will touch, and is checked before it runs. One language to cut cost, grade how your product is used, score yield in your own domain, and stop an agent that goes rogue.
- cut cost
Run the steps your agent repeats without paying a model, and compact when your work is at a break, not at the cliff.
rustPreflight · tune/compaction - grade product use
Grade every session against your product's own checks: what passed, what failed, and the lines that decided it.
eval/play - score your domain
Teach yield what counts as reading, changing and checking in your field, so a session is scored on your terms.
yield/domain - stop a rogue agent
The same rules that grade a finished session run as the agent works, and stop the next step of a chain.
eval/guards · secretScan · fetchSanitized
It starts from what your agents already repeat. Here, sed ran 455 times before a change. The circuit below gates a Rust tree, format, lint, tests and banned patterns, in one call that needs no model. Once you say yes, Olki runs it for you.
-- circuit rustPreflight -- hash #51f81d220a05f5ba314df6ee3f4f7c70bc25c59629c876fe88ec9b37504753be -- effects FS(read), FS(read, .), FS(write, .), Present(stdout), Proc(cargo), Proc(git), Proc(rg) -- check passed circuit rustPreflight "A gate for a Rust tree …" : { src: Path } -> { workspace: Text, fmt: …, lock: …, clippy: …, tests: …, denies: Nat } let fmt = ( commandPasses --cmd "cargo" --args ["fmt", "--all", "--check"] ) let clippy = ( buildPasses --cmd "cargo" --args ["clippy", "--all-targets", "--", "-D", "warnings"] --writes ["target"] ) let tests = ( buildPasses --cmd "cargo" --args ["test"] --writes ["target"] ) let denies = ( rustDenyPatterns --dir $in.src )
run the checks your agent repeats as one circuit
#One record, an edition for everyone who answers for it.
Olki writes the record up as a newspaper. Each edition leads with what its reader answers for: you, finance, security, the product owner, the harness and inference providers, the circuit builder.
Every story reads as a decision does: the answer, what happens if it is left alone, what to decide, and the evidence under it. The stories differ by reader; the record under them is the same.
#Without touching your model's weights.
Olki learns the way a good team does. The model stays the same; the run around it gets better.
It watches, makes sense of what it saw, decides what to change, and changes the next run, and each run starts from the last.
#Watch first. Nothing changes until you say so.
Olki works with what you already run: Claude Code, Codex, Cursor, OpenCode and more, with any model. No SDK to add. It sits outside the agent, and the record stays on your machine.
It starts in shadow: it records what it would have done, and does nothing. The trail stays as written, and the agent cannot edit what it is checked against. Turn each switch on when the record has earned it.
#Stop paying for runs you can't read.
Olki is in private release. Ask for a token and install it. Olki starts reading your agents in seconds, and changes nothing until you say so.
-
first
We send you a token for the installer.
Ask for a token -
then
Install it. Olki finds the harnesses you run, Claude Code, Codex, Cursor, OpenCode and more, and starts in shadow: it records what it would have done, and changes nothing.
curl -fsSL -H "Authorization: Bearer $OLKI_TOKEN" \
https://get.olki.ai/install.sh | sh -
in seconds
Open Olki. From your agent's next command, every line arrives typed, priced and held to your rules.
olki front open -
as it learns
The longer Olki watches, the better it knows the shape of your work, across every harness: when to compact, what repeats, what to check. It shows what it would have done, and why; turn on the parts that earned it.
olki shadow.report
Leaving is one command: olki uninstall --all says what goes and what stays, and asks before it removes anything.
