v0.26.0·Apache-2.0·Go 1.27·pre-1.0
Durable, accountable AI agents in Go.
A Go framework for AI agents that move money: risky calls approved, every action recorded and verifiable.
$ brew install bide-ai/tap/bide # crash an agent mid-payment, no API key $ bide demo
No Go install needed for the demo with Homebrew. Or: go run github.com/bide-ai/bide/cmd/bide@latest demo

Move money
Refunds, payouts, purchases, credits. A side effect that must not happen twice, and that someone may need to approve first.
Change records
Customer records, invoices, tickets, entitlements. A write that must not run twice, even if the process dies mid-write.
Act under audit
Work a reviewer will ask about later: who approved it, before it ran, and was anyone told. Answered from evidence, offline.
The problem
Your agent crashed mid-refund. Did the customer get charged twice?
Most agent frameworks recover by re-running. That is fine for a model call. For a refund, an email or a wire, it is a second refund, a second email, a second wire.
We ran a non-idempotent charge through 204 to 209 crash schedules per framework, then recovered the way each one supports.
Reproduce the benchmark →Every adapter passes a fairness test: a run with no crash charges exactly once, and where a framework has resume, it works. LangGraph runs in its most durable documented mode. These frameworks document that steps must be idempotent; this measures that documented model. Worst-case counts track how often a framework saves state, so they are not a ranking: anything above 1 is a double charge.
What bide does instead
When the outcome is unknown, it stops.
bide writes a durable attempt marker before every side effect, so a resumed run can tell "never started" from "started, outcome unknown". The unknown case is resolved in a fixed order.
Retry-safe
Declared read-only or idempotent, or sent with an idempotency key. Retried automatically; the provider dedupes.
→ auto
Queryable record
A sent-message id, a row, a provider record. A reconciler resolves it with ResolveHalt after a grace period, with evidence.
→ auto, reconciler
Unknowable
Nothing can establish what happened. The run halts and a person is notified.
→ HALT, wait for a human
A pause you can clear beats a double-fire you can't.
The API
Gate the risky call. The rest is plain Go.
Write the agent in ordinary Go. Mark the calls that move money, and bide holds them for the people your policy names.
- ✓k of n named approvers, each signing the exact tool and arguments
- ✓Separation of duties: with ExcludePrincipal, the requester's decision never counts
- ✓Deadlines: set a Timeout, and a gate nobody decides in time expires; the call never runs
- ✓Signing keys can live in an HSM or a cloud KMS, behind one interface
- ✓Or author it as a flow in YAML, with the policy checked in CI
// A refund that needs 2 of 3 named approvers before it runs. refund := agent.MustFunc("refund", "Refund an order", doRefund, agent.WithApproval(&agent.ApprovalPolicy{ Need: 2, Approvers: []string{"ops", "finance", "risk"}, ExcludePrincipal: true, // the requester never counts Timeout: 24 * time.Hour, // undecided in time: never runs })) store, _ := sqlite.Open("run.db") // pure Go, no cgo; Postgres for many nodes journal, _ := agent.NewJournal(store) a, _ := agent.New(model, journal, agent.WithTools(refund), agent.WithApproverVerifiers(lookupApprover), // id -> key, from your PKI ) // Crash anywhere. Run the same ID again: it resumes from // the journal, and the refund fires at most once. res, err := a.Run(ctx, "refund-1042", agent.UserText(ticket), agent.WithIdentity(agent.Identity{OnBehalfOf: requester})) if pend, ok := errors.AsType[*agent.ApprovalPending](err); ok { ask(pend) // paused at the gate until 2 of 3 sign }
version: 1 flow: refund entry: assess nodes: - {name: assess, block: assess, safety: readonly} - name: refund block: refund safety: side_effect approval: {need: 2, approvers: [ops, finance, risk], exclude_principal: true} - {name: notify, block: notify, safety: readonly} - {name: refund_small, block: refund_small, safety: side_effect} wiring: - switch: assess when: [{pred: over_threshold, to: refund}] else: refund_small - edge: [refund, notify] assert: - every path to refund passes approval >= 2 of 3 excluding the requester # bide check flow.yaml exits 1 if any path reaches the refund # without that gate. With -diff main -check -fail-on-weaken it fails # a pull request that lowers need or drops exclude_principal.
$ bide init refund && cd refund && go mod tidy && go run . paused before node:refund: 0 of 2 approvals (pending ops, finance, risk) ops approved {"order":"order-42","amount":120,"reason":"arrived damaged"} paused before node:refund: 1 of 2 approvals (pending finance, risk) finance approved {"order":"order-42","amount":120,"reason":"arrived damaged"} done: refunded: arrived damaged (120) refunds the provider holds: 1 wrote evidence.json, approver-keys.json and keys/log.pub $ go run . # again: reads the finished run back, refunds nothing
A full agent framework
Everything you build agents with, on one journal.
Models, tools, flows, sub-agents and long-running ambient work all run on the same durable journal, so each keeps the guarantees.
Models
Native Anthropic and Gemini, and any OpenAI-compatible endpoint: OpenAI, Ollama, vLLM, DeepSeek, Groq, OpenRouter, Azure, xAI. Extended thinking with tools, prompt caching, images, one tool schema emitted per provider dialect.
Tools and MCP
Typed Go tools with schemas generated from the type. MCP servers as tool sources, with their annotations mapped to safety and approval gates.
Composition
Sub-agents that share the journal, durable Parallel fan-in, sagas that roll back in reverse and stop on an unknown outcome, and typed plan flows with switch, join and loop.
Ambient agents
Durable Sleep and WaitUntil that survive restarts, a pluggable Waker, signals applied once even when redelivered, and typed Interrupt for a human decision.
Reliability
Per-attempt timeouts, retry that classifies transient and terminal errors, hedged model calls, rate limits, token budgets across an agent tree, and spend read from the journal, discarded retries included.
Run and observe
Streaming, typed output, durable sessions, OTel GenAI spans in one line, a scripted test model for offline tests, and SQLite or Postgres with leases and continuous recovery.
One journal, five guarantees
The loop is ordinary Go. The guarantees come from the journal under it.
- Calling a finished run again returns the stored answer, with no new model call
- A resume reads its limits, prompt and tool filter from the journal; a redeploy that changes them is refused
- With Postgres, any node resumes any run; a per-run lease keeps one driver at a time
- 20,000 runs, 5,000 in flight, in about a second on a 4-vCPU CI runner (in-memory store, simulated model latency)
- Inclusion, consistency, and proofs that an action never happened
- Anchoring to S3 Object Lock or a locked Google Cloud Storage bucket
- Approvers bound to certificates from your own CA; a revoked one does not count
- Signing keys in PKCS#11, AWS KMS, Google Cloud KMS or Azure Key Vault
- The convergence theory is proved in Rocq, axiom-free
- Each machine is re-checked by a checker extracted from that proof
Approvals a reviewer can check
Who approved, before it ran, over exactly these arguments.
Every decision is signed over the run, the call, the tool and its canonical arguments, then counted by the gate and kept on the audited trail.
- ✓Decide in a terminal or a browser. bide approve shows the call and the SHA-256 the signature binds. The browser page signs with a key it cannot export.
- ✓Certificate-bound approvers. A seat can be a person your CA certified; revocation is checked just before the call runs.
- ✓Decision receipts. Each approver keeps one, and a later check notices a decision deleted after a signed head committed to it.
- ✓Earned authority. An agent's limit rises one rung per clean streak, up to a ceiling the root signed, and drops on any anomaly.
- ✓Escalation. An approval nobody acknowledges escalates, up to four steps, until someone decides.
bide compares ids; tying a key to a person is your identity provider's job. Signers are tested against SoftHSM2 and emulators, not a live cloud.

Bound what injected text can do
An email tells your agent to refund $4,800. Now what?
These controls bound the consequences of instructions hidden in content the agent reads. They do not detect or prevent the injection itself.



The tools
See it, sign it, prove it.
One bide binary: a local, read-only page for runs and flows that makes no outside request, a terminal for approvers, a flow editor, and 17 offline checks an auditor can run.
See a flow's risk before it ships
Each node is colored by what a crash does to it: a side effect halts and asks, a read-only step re-runs. Approval gates are marked, and policy assertions are checked on the graph.
bide view -config flow.yamlRead the guide →
Policy as a test
An assertion such as "every path to charge passes approval >= 2 of 3" is decided on the graph, without running anything. A violation comes with its shortest counterexample path, in red.
bide check flow.yamlRead the guide →
A pull request that weakens a gate fails CI
Compare a flow with any git revision. A removed gate, a lower need, a dropped requester exclusion, a longer or removed deadline, a new ungated side effect or a loosened assertion is flagged, and the check exits 1.
bide check flow.yaml -diff main -check -fail-on-weakenCLI reference →
Decide from a terminal
Approvers see the call read from the journal, its arguments and the SHA-256 their signature binds. A requester whose decision would not count is refused before anything is recorded, and every decision leaves a receipt.
bide approve -db run.db -listRead the guide →
Prove people were told
Checked offline against the journals and the signed trail: every halt and every waiting approval was delivered, and your endpoint acknowledged it in time. One that nobody was sent fails. An acknowledgement means your endpoint answered, not that a person read it.
bide audit notifications -db run.db -pubkey keys/log.pub -sth notify-run.sth.jsonRead the guide →

Build flows visually experimental
A local visual editor for flow configs: the graph, an outline and an inspector. Add, rename and reorder nodes, wire edges, switches and joins by form or by dragging between nodes, and set each node's approval gate in a form, with the assertions' verdicts live as you edit. An edit that weakens a gate against the committed policy raises a banner that cannot be closed, and every save shows a diff first.
bide edit flow.yamlRead the guide →
Know what is waiting on a person
Every run waiting for a person, nearest approval deadline first: approvals pending, halts with an unknown outcome, and whether someone was notified and acknowledged. Try it with no code: bide sample opens 14 runs in every state. Or open the sample in your browser →
bide view -db run.dbRead the guide →
Compared
Where bide differs, and where others are stronger.
| bide | Temporal | LangGraph | Go agent SDKs | |
|---|---|---|---|---|
| Crash after the effect ran, before its result was saved | Halts with outcome unknown instead of re-running | The activity may run again; idempotent activities recommended | A started task may run again; idempotency keys recommended | Re-ran in our benchmark (worst case 4 to 64 charges) |
| Multiple approvers | Built-in m-of-n gate; each approver signs the exact call | Build it in workflow code on signals | Build it in graph code on interrupt | Not compared |
| Proof the approval came first | bide audit verify-approvals, offline | Not described in the docs we cite | Not described in the docs we cite | Not compared |
| Deployment | A library and a database you already run | A server and a worker fleet, or Temporal Cloud | A library, with a hosted platform | A library |
Sources, quotes and the idempotency-key comparison: bide-ai.com/trust/comparison
Claims you can check
Each claim links to its evidence and its limits.
Built toward what a bank asks of software that moves money: keys outside the application, separation of duties, a tamper-evident trail, explicit failure modes. Not certified against any standard.
No third-party security audit yet. Known limitations · Control mapping · Stability · Operations
Start
From zero to a verified run.
No API key needed. Everything runs on your machine, on SQLite.
bide demobide init refund && cd refund && go mod tidy && go run .bide audit verify-evidence -evidence evidence.json -pubkey keys/log.pubRecipes to copy
All recipes →Plus 25 runnable examples, including a Stripe refund in test mode with a reconciler, HSM signing, SSO certificates and MCP. Browse the examples →
From the blog
All posts →Status
Working v0, released often (31 releases since 2026-09-28). On 0.x, a minor version may break the API, and journals are not promised to resume across pre-1.0 releases: finish in-flight runs before you upgrade. Go only today; other languages are on the roadmap.
Talk to us
Building agents that move money, change records, or act under audit? Questions, feedback and pilots: dayna@blackwell-systems.com
Crash an agent mid-payment. It never charges twice.
$ brew install bide-ai/tap/bide && bide demo