Reliability & Performance
The dials that make bots and code sessions dependable when nobody is watching: self-checked answers, verified work, cost you can see, and speed where it is free. Every one of them works the same on every AI provider you connect.
How a run protects itself
Every bot run carries five guardrails, always on: a step limit, a wall-clock deadline, a token ceiling you set per run, a loop detector that stops a bot repeating the same failing call, and a billing check before every model call. Tool results are size-bounded with an honest marker — when something is trimmed, the bot is told exactly what was cut and how to fetch the rest, so it re-asks instead of guessing around a hole. Independent read-only steps (three web searches, five file reads) run at the same time, so a research-heavy step takes as long as its slowest lookup, not the sum of all of them.
Self-check: catch the run that finished wrong
A run can stop confidently and still be wrong — the file went to the wrong place, the answer addressed a neighbouring question. Self-check adds the missing guardrail: before a bot's answer settles, a fast, cheap model judges it against your request and against what the tools actually did. A miss earns exactly one correction pass; the corrected answer is what you see.
- Open your bot's Settings
- Under the run controls, set Self-check answers:
- Unattended runs only (recommended) — scheduled tasks, channel messages and sub-agent runs, where nobody would catch a miss
- Every run — including conversations you are watching
What it costs
One small extra call per checked run, on your provider's cheap tier and your own key, metered like everything else. Heartbeats and nightly maintenance are never checked — their routine replies aren't worth a call each.
Code sessions have the same dial: flip Self-check in the session's composer. The agent's finished answer is judged against your request and its own tool record — a claimed file with no successful write, claimed passing checks with no run shown — and a miss earns the same single correction pass, with the draft preserved in the thinking log.
Fast tier for mechanical steps
Mid-run, many bot turns are pure dispatch — the model is deciding which tool to call next, not writing anything you will read. Fast tier for mechanical steps (bot Settings) runs exactly those turns on your provider's cheap model. Your chosen model always writes the answer: a routed step that tries to answer instead of dispatching is discarded and redone on your model, automatically. Routed steps are labeled in the transcript with the model they ran on, so the saving is visible rather than taken on faith.
Tool definitions on demand
A bot with many capabilities sends the model a long list of tool definitions with every request — tokens on every call, and more options for the model to weigh. Tool definitions on the wire → Core set + load on demand (bot Settings) sends only a core toolkit up front; the bot attaches another category the moment a task needs it, and your prompt lists everything that is available so nothing is hidden. Worth trying on bots with most capabilities switched on; leave it on "All tools up front" if you prefer today's behavior.
Loops: runs that keep going until done is provable
Four kinds of loop, one rule underneath them all — the model that does the work never gets to grade its own stopping point — and every one behaves identically on every AI provider you connect:
- Turn-based — the ordinary conversation: the agent works, checks, answers, and you steer the next turn. Self-check (above) is the guardrail here.
- Goal-based — when your request states what done looks like ("until the tests pass", "every report triaged"), the agent declares the condition as its goal. Each time it tries to finish, an independent evaluator on the fast tier — with fresh context, never the reasoning that produced the answer — checks the condition against the answer and the tool record. Unmet sends the run back with exactly what is missing, up to a hard attempt cap. Works in bots and code sessions.
- Time-based — scheduled tasks: the same instruction on a cron, results delivered where you chose.
- Proactive — compose them: a scheduled task whose instruction declares a goal and deploys sub-agents is a stream of work that triages, acts, verifies, and only surfaces what needs you.
Say the next thing any time — queue it, or interrupt
You never have to wait for a running turn before saying the next thing. Every composer — a chat, a code session, a bot session — carries a small Queue / Interrupt switch beside its model controls, and it decides what a message sent mid-turn does. The choice is remembered for you, so a switch flipped in one composer holds in every other, on every device.
- Queue (the default) — the message waits, marked Queued, and is answered as its own turn the moment the running one finishes. Nothing already under way changes course. Send three messages in a row and they are answered in order, one turn each.
- Interrupt — the message reaches the running turn now. A bot or a coding agent takes it at its next step, framed for judgment: if it changes the current task, the agent adopts it on the spot and keeps the work already done; if it is an independent new task, the agent deploys it as a parallel sub-agent worker and keeps going — its results arrive separately; if it is just "how's it going", you get an answer in passing. A plain chat answer stops where it is, keeps what it wrote, and your message is answered next. A run with no step to hand a note to — a CLI on your own machine, a provider that answers in one shot — is stopped, and your message runs as the very next turn.
Either way nothing is dropped: if the running turn ends before an interrupt is taken, the message is answered exactly as a queued one would have been. This holds on every provider and every way of paying — managed credits, your own keys, or a runtime on your own machine — and from the composer, the mobile app, a connected channel like Slack or Telegram, and when a bot drives its own code session. A visitor on a shared link can only queue: a stranger can wait behind your run, never cut into it.
Auto-resume after a usage limit
A run on your own subscription can stop mid-task because the provider's usage window closed ("session limit — resets 6:50am"). That is a window, not a failure: the session reads the reset time out of the message, schedules its own continuation for the moment the window reopens, and picks up exactly where it left off. The error notice shows when it will resume, with a checkbox to turn auto-resume off per session. Limits are treated as the expected condition they are — no alarms, no lost work, a hard cap on consecutive resumes so nothing ever loops.
Learned memory: the same correction never twice
Separate from a bot's memory files, every bot keeps a learned memory: habits you keep asking for, corrections it should not need twice, procedures that worked. It learns two ways — it saves a lesson itself when you correct it or a procedure succeeds, and after a run where you visibly corrected it, a fast-tier pass distills the exchange into at most two short lessons. Learning is deliberately cheap: ordinary runs never spend a distillation call, the whole memory compiles into one small, bounded block of the prompt, and repeating a lesson reinforces it rather than duplicating it. The strongest lessons rise; stale ones retire. Same behavior on every provider.
Run health: where the time and money go
The bot dashboard's health strip shows, alongside the cache hit rate: the p95 run time, the p95 run cost, and the slowest tool of the week. Every run records its duration, steps, tokens and priced cost — priced from the same table billing charges from, so the number you see is the number you paid. When a run feels slow, the strip says whether it is the model or one tool doing the waiting.
Watching a run live
Bot runs stream: the reply paints as it is written, above the working indicator, instead of arriving all at once at the end. Mid-run you can steer ("focus on the March numbers", with the composer's switch on Interrupt) or stop — corrections are taken at the next step without restarting the work already done.
The rigor playbooks
The Templates library ships playbooks that teach any bot the habits of careful operators — install the ones that fit from your workspace's Templates page:
- Prove it before you report it — never "done" without evidence: the file read back, the output read, the URL probed
- Debug with rigor — reproduce first, eliminate hypotheses, prove the fix with before-and-after
- Drive a code session to done — the bot manages a coding agent like an engineering lead: definition of done first, steer early, demand the test output and the PR link before believing "done"
- Decision log for long runs — an append-only record of every judgment call, so an hour of autonomous work reviews in five minutes
- Nightly code audit — one small, verified maintenance pull request per night
- Adversarial review — independent reviewers, ideally on a different AI provider, try to break the work before you trust it
- Arena: best of N attempts — parallel attempts at the same task, judged against criteria fixed up front, best parts merged
Two matching skills live in every provider's skills shelf — Prove it before reporting it and Plain writing — three-line habits you can switch on for any credential, configuration or bot.
Your playbooks travel to your own machine
When a bot dispatches coding work to your own computer (the Local machine provider), its installed playbooks travel with the job as Agent Skills — the open SKILL.md format that Claude Code, Codex CLI, Gemini CLI and Cursor all read natively. The companion writes them into the session's managed checkout before the coding tool starts, keeps them out of your commits and pull requests, and removes any you uninstall. The same playbook disciplines the run whichever vendor's tool executes it.
One behavior, every provider
All of the above lives in Configure My AI's shared runtime, not in any provider integration: self-check, routing, on-demand tools, run health, streaming and the playbooks behave identically whether the bot runs on Anthropic, OpenAI, Google, xAI, Mistral, Cohere, DeepSeek, a custom endpoint, Ollama, or a subscription on your own machine. Where a provider cannot do something (a model that cannot stream, a key with no cheap tier), the feature stands down silently rather than changing the behavior you chose.