Nothing in your tests acts back.
Mocks return what you wrote. Test accounts never reply. So agents pass every test and fail in production. In Ancha the tools, the people and the clock all react, so you find out before production does.
The model keeps the rules.
What fails is everything between people.
Give an agent a clear policy and it keeps it: no refund twice, nothing over the limit without approval, never another customer's account. Put a customer, a manager and your agent in one loop and it answers the wrong person, never asks the one who knows, and drops a fact on the way.
Those are the failures that reach production, and a mock can't catch one. Ancha plays the other people, with roles and things only they know, so the whole loop gets tested.
What your agent does stays done.
A mock returns the answer you wrote down. A vendor test account is real, but it never replies, never pages anyone and can't be reset between runs. Neither one changes when your agent acts, so a test passes whether the agent refunded once or twice.
In Ancha every tool keeps real state and every action has consequences. A refund shows on the charge. A merge deploys. An alert pages someone, and that someone answers.
Your evals already have a home.
The world is what's missing.
You already run evals somewhere: pytest, vitest, Braintrust, LangSmith, a workflow in CI. We don't replace it. What you're missing is a realistic place to run it, with the systems and the people your agent will meet.
Ancha is that place. It plugs into the runner you have and stays out of the way.
Everything that happens is an event.
One store holds every tool's state, with one clock and one log. Each call your agent makes, each reply, each deploy and each minute that passes is an event, and everything in the world reacts to events through the same tools your agent uses.
That is how a merge deploys, a page gets acknowledged, and a reply that would take two days arrives in seconds, consistent across every tool.
Grade the end state, and the path where it matters.
A transcript tells you what the agent said. The world tells you what happened. Ancha grades the end state first: the refund happened once, the incident is closed, production has the fix.
Then the path, where it matters: the right person was asked, the answer was passed on, nothing was deleted without approval. A judge reads tone. Everything else is a check that either holds or doesn't.
End state
- refunded_once
- incident_resolved
- production_has_fix
Path
- asked_the_one_who_knew
- approved_before_refund
- deleted_nothing_unasked
Tone
- polite_to_the_customer
- read by a judge
The world adds no noise.
Your agent is nondeterministic enough. Every Ancha world is frozen by hash, every simulated person can be replayed, and a trial that failed reruns exactly as it ran.
When a run flakes, you know it was the agent, and you have the trial that proves it.
Never a silent 200.
When your agent calls something Ancha doesn't cover, the call fails loudly and the gap is reported. A made-up answer teaches your agent the wrong lesson and tells you nothing.
We would rather you know.
A mock
GET /v1/disputes/dp_7QpAncha
GET /v1/disputes/dp_7QpBuilt for agents that wait.
The agents being built now don't finish in one turn. They take a webhook, ask for approval, wait for CI, and come back when someone replies. Ancha runs the clock, so a two-day wait takes seconds and the agent's own timers follow.