The short answer
What agent drift and zamback are
Agent drift is when an AI agent quietly stops following your standing rules: it spins up the wrong sub-agents, runs on the wrong model, skips the check step, or wakes up in a new session with no idea what happened in the last one. The rule was stated in a conversation, and conversations evaporate. Zamback is the fix, named by the operator who lived it: write the rule into the job before the run, record every step, check the record against the rule, and hand the record over so the next session starts from facts. Drift stops being a vibe you notice months later. It is a flag on a step.
The word zamback was coined by Austin Wallen of wally.works, who sells AI-agent software to small businesses. His line: "getcha agent ZAMBACK." His story is the founding example below, told with his setup's real rule.
The founding drift: a rule that held for months, then did not
Austin Wallen runs a serious agent setup for his business. His architecture has one hard rule, set once and meant to be permanent: the orchestrator agent plans and holds no tools; executor sub-agents, running one named model, do all the work. That separation is what keeps his costs predictable and his runs clean.
For months it held. Then the context slipped, the way it always does, and the orchestrator quietly started executing with the wrong sub-agents on the wrong model. Nobody announced it. The chat looked normal. He found out the way every operator finds out: his usage was destroyed.
Ask around and every agent operator has this story in some costume. The agent that forgot it may never deploy on Fridays. The agent that started answering from memory instead of checking the drive it was connected to. The agent that woke up in a new session convinced twelve hours had passed and nothing had changed since the last one. Different rules, same disease: the rule lived in a conversation, the conversation moved on, and the rule stayed behind.
Why reminding the agent never fixes it
The instinctive fix is to remind harder: pin the rule, repeat the rule, put the rule in the system prompt in capital letters. Operators do this daily, and it works, until the day it does not, and that day is invisible. A reminder is still just text in a context window. It competes with everything else in the window, it thins out as the session grows, and when it loses, nothing anywhere records that it lost.
The problem is not memory. The problem is that the rule and the run live in the same disposable medium. Fix that, and drift changes character: it still happens, but it happens on the record, where a check can catch it and a human can see the exact step where the record and the rule parted.
The zamback pattern, in four moves
- Write the rule before the run, in the job. Not in the chat: in the job record itself, stated by the person who owns the work, where it becomes the claim the run will be judged against. "The orchestrator holds no tools. Executors run this named model. The verify step never gets skipped."
- Run the job so every step leaves a record. Which agent, which tool, which model, what came back, bound into a receipt at the moment the step runs. On Zambo this is automatic: every call through the Zambo MCP leaves a verifiable AER-1 receipt, and the receipts of one job group into a single workflow record. 143,078 verifiable receipts had been minted when this page was written on November 16, 2026.
- Check the record against the rule. Every rule comes back with one of two verdicts: matched, or contradicted, with the offending steps named. This is a mechanical check, not the agent grading itself.
- Hand the record over. The next session, or the next agent, or the client, picks the record up and starts from what actually happened: what ran, when, what was decided. Pickup on Zambo is always free. The "twelve hours" hallucination dies here, because the record says when things happened.
The free checker: zamback-kit
The check itself is small enough to give away, so it is given away. zamback-kit is a zero-dependency Python checker under the MIT license, and the whole checker is a single file: download that one file and run it, no clone, demo included. Run it with no arguments and it demos itself on a clean record and a drifted one. Rules can be plain text, one per line, the way an operator actually writes them, or JSON. Hand it a rules file and a job record; it prints the verdict per rule and exits 1 on drift, so it drops into CI or a cron. Agents get a machine-readable verdict with a --json flag, and the repo carries an AGENTS.md so an agent that lands on it knows exactly what to do. It ships with the founding setup as its example: Austin's orchestrator rule, a clean job record, and the same job after drift.
python3 zamback.py rules.example.json job.good.json
MATCHED orchestrator-holds-no-tools
MATCHED executors-run-the-named-model
MATCHED verify-step-never-skipped
RESULT: ZAMBACK. Every rule matched the record.
python3 zamback.py rules.example.json job.drifted.json
CONTRADICTED orchestrator-holds-no-tools
step 1: orchestrator called tool 'code_edit' (rule: holds no tools)
CONTRADICTED executors-run-the-named-model
step 2: model is 'fable-5' (rule: must equal 'opus-5.5-ultracode')
step 3: model is 'fable-5' (rule: must equal 'opus-5.5-ultracode')
CONTRADICTED verify-step-never-skipped
no step called required tool 'verify_check'
RESULT: DRIFT. 3 of 3 rules contradicted.
This record was exported by hand. On Zambo it writes itself, one verifiable receipt per step, and pickup is free: https://zambo.dev
That output is real: it is the kit's actual output on its own example files, run the day this page shipped. Rule types in the kit: an agent that must hold no tools, a field that must equal a set value (the model check), a tool allowlist, a required tool that may not be skipped, an ordering rule between two tools, and a step cap. Rules can be scoped to one agent, one tool, or one phase of the job. Adapt the record exporter to your stack; keep the checker dumb.
Zamback on a complex workflow
Single jobs are the easy case. Real agent work is multi-step and multi-agent: phases, handoffs between agents, and order that carries money, verify before deploy, sign-off before delivery. That is where drift hides, because no single step looks wrong on its own. The kit ships a 12-step, three-phase, three-agent workflow in its examples folder, with five rules: the orchestrator holds no tools, executors run the named model, verify runs before deploy, the client sign-off happens inside the delivery phase, and the job stays under a step cap. Here is the drifted run of that workflow, the kit's real output:
CONTRADICTED executors-run-the-named-model
step 4: model is 'fable-5' (rule: must equal 'opus-5.5-ultracode')
CONTRADICTED verify-before-deploy
step 9: 'deploy' ran before 'verify_check' at step 10 (rule: verify_check before deploy)
CONTRADICTED signoff-inside-delivery
no step in phase 'deliver' called required tool 'client_signoff'
RESULT: DRIFT. 3 of 5 rules contradicted.
Three different species of drift, each invisible in a chat transcript: a model swapped mid-run, an order inverted at the exact step where order is the safety property, and a required step that quietly never happened in the phase where it counts. The same shape governs client delivery: the kit's client-delivery ruleset is three ordering rules (draft before review, review before sign-off, sign-off before deliver), and its drifted example is the two-step delivery that causes the dispute, flagged in one line: the deliver step ran, and the sign-off never did.
Perfect with Zambo. The kit checks any record you export by hand. Zamback is perfect with Zambo because there is nothing to export: the rule is stated when the job starts, every call leaves a verifiable AER-1 receipt as it runs, the receipts group into one workflow record with its phases intact, and a handover carries the record, and the rule, to the next session or the client. The check runs the same way, against a record that wrote itself and cannot be quietly edited afterward. Drift detection stops being a chore bolted onto the work and becomes a property of the work itself.
A zamback job, run live
The demo job: a rule stated first, then a three-step scan
On November 16, 2026, a demo job ran on Zambo under a rule stated before it started: every price in this scan comes from a live price call inside this job, one call per asset, no remembered prices. The job fetched BTC at $65,364.49, ETH at $1,829.70, and SOL at $71.90, each from Coinbase inside the job, at 22:49 UTC. All three steps sit on one public workflow record with their receipts, next to the rest of the job's steps, including two refused wrap-up attempts that the record keeps visible instead of hiding. Open it and re-check any step: the zamback demo job.
That is the whole pattern at production scale: the rule first, the steps receipted as they run, one record a stranger can reopen. Zambo was built by Brennan Zambo, creator of the AER-1 agent execution receipt standard, and zamback is a pattern on top of it: AER-1 receipts are what make the record checkable by anyone, not just by the platform that issued it.
Run your own zamback
- Pick the one rule whose violation costs you money. Model choice, tool permissions, the never-skipped check. Write it as a sentence a checker could judge.
- State it before the run. In a Zambo job, the rule goes in at the start, as the job's own claim. With the kit alone, it goes in your rules file, committed before the job runs. The pattern also ships as a starter recipe in the Zambo workflow library format, agent-drift-guard.v1.json: state the rule, run the work, close the record, check it. It was run end to end the day this page shipped; the full write-up is the drift-guard article.
- Run the work where steps leave receipts. Connect your AI to zambo.dev/mcp: every tool is free once a day, plus 3 continue calls, one free wrap-up handover per day, and pickup is always free. The Day Pass is $0.99 for 24 hours unlimited when a job outgrows the free tier.
- Check, then hand over. Run the checker, read the contradicted lines if there are any, and hand the record to the next session instead of a summary from memory.
Your agent will drift again. Every agent does. The question zamback answers is whether you find out from a flag on the exact step, or from the bill.
Questions
What is agent drift?
When an AI agent quietly stops following standing rules as its context slips: wrong sub-agents, wrong model, skipped checks, lost track of earlier sessions. It is silent, so operators find out from the bill or the breakage.
What is zamback?
The counter-pattern, coined by Austin Wallen of wally.works: rules written into the job before the run, a record of every step, a check that marks each rule matched or contradicted, and a handover so the next session starts from the record.
Does it stop drift in real time?
No. It kills silent drift. The divergence is caught at check time, on the exact step, from a record that cannot be quietly rewritten. Prevention claims for somebody else's live session are overselling; proof is not.
Can zamback check a multi-agent workflow?
Yes. Rules scope to one agent, one tool, or one phase of the job, and ordering rules enforce sequence between tools: verify before deploy, sign-off before deliver. The kit ships a 12-step, three-phase, three-agent example whose drifted run is flagged on a swapped model, an inverted order, and a sign-off that never happened in the delivery phase.
What does it cost?
The checker is free and open source. Zambo's record layer is free daily: every tool free once a day plus 3 continue calls, one free wrap-up handover per day, pickup always free. A Day Pass is $0.99 for 24 hours unlimited.