Skip to content

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

Explore a sample run in your browser →

bide demo
bide demo: an agent is killed mid-charge and the restart halts with outcome unknown instead of charging again, and ops is notified; then a refund requested by untrusted inbound email is held with the reason; the requester is refused by separation of duties; two approvers sign, the refund runs once, and the audit verifies
The demo kills an agent after the charge and before the journal write, halts instead of charging again, then edits one amount in a copy of the journal to show verification fail.

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 →
bide
Go · main at 72ffb78 · 209 schedules
Never repeated
at most once held
LangGraph
Python · 1.2.19 · SQLite and Postgres
Charged again
worst case: 3 charges
adk-go
Go · v2.7.0
Charged again
worst case: 4 charges
trpc-agent-go
Go · v1.11.2
Charged again
worst case: 6 charges
langchaingo
Go · v0.1.15 · no crash durability
Charged again
worst case: 64 charges
eino
Go · v0.9.22 · no crash durability
Charged again
worst case: 64 charges

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.

1

Retry-safe

Declared read-only or idempotent, or sent with an idempotency key. Retried automatically; the provider dedupes.

→ auto

2

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

3

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
}

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.

Already on ADK, Eino, trpc-agent-go or langchaingo? Wrap the side effects in agent.Step and they get the journal: at most once across a crash, and on the audit trail.
Nothing in your go.sum you did not ask for. The core module requires no other module, and a test fails the build if that changes. SQLite, Postgres, OTel and the cloud SDKs are separate modules.

One journal, five guarantees

The loop is ordinary Go. The guarantees come from the journal under it.

01At most onceA side effect fires at most once, even across a crash, so it does not have to be idempotent.
  • 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
The guarantee →
02A library, not a clusterDurable execution from a store you already run: SQLite on one machine, Postgres for many. No server, no worker fleet.
  • 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)
Durable steps →
03A verifiable audit trailThe journal is committed to an RFC 6962 Merkle tree. A third party checks proofs offline without trusting your database or logs, and against the operator once heads are anchored outside their control.
  • Inclusion, consistency, and proofs that an action never happened
  • Anchoring to S3 Object Lock or a locked Google Cloud Storage bucket
Audit →
04People in controlk-of-n signed approvals with separation of duties and deadlines, and a notifier that records each delivery and whether your endpoint acknowledged it.
  • 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
Human approval →
05experimentalProvably convergent stateShared state many agents change converges to one valid state in any event order, for state that meets conditions checked at build time.
  • The convergence theory is proved in Rocq, axiom-free
  • Each machine is re-checked by a checker extracted from that proof
Scope and limits →

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.

The browser approve page for a waiting refund call: the approver's public key and fingerprint, every argument, the arguments' SHA-256, and Approve and Reject buttons

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.

bide view run page for refund-4801, waiting for approval: the approval gate card is open on why this gate, untrusted content from inbound-email read by tool read_email, with the three pending approvers
The agent read an inbound email, then asked for a refund. The call waits for 2 of 3 approvers, and the gate says why.

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 →
bide view -config: a refund flow's risk map, each node colored by what a crash does to it, with all four policy assertions holding

Compared

Where bide differs, and where others are stronger.

bideTemporalLangGraphGo agent SDKs
Crash after the effect ran, before its result was savedHalts with outcome unknown instead of re-runningThe activity may run again; idempotent activities recommendedA started task may run again; idempotency keys recommendedRe-ran in our benchmark (worst case 4 to 64 charges)
Multiple approversBuilt-in m-of-n gate; each approver signs the exact callBuild it in workflow code on signalsBuild it in graph code on interruptNot compared
Proof the approval came firstbide audit verify-approvals, offlineNot described in the docs we citeNot described in the docs we citeNot compared
DeploymentA library and a database you already runA server and a worker fleet, or Temporal CloudA library, with a hosted platformA library
Temporal is stronger if you need workers in several languages (it has eight SDKs), a clustered scheduler, or a managed service.
LangGraph is stronger if you work in Python or TypeScript, or want hosted tooling such as LangSmith.
bide is pre-1.0 and Go only, with a small set of model adapters, and has had no third-party security audit.

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.

14TLA+ models of the runtime's protocols
28bugs the models found in bide's own design or code
495model configurations checked in the merge queue
17offline bide audit checks
0modules the core requires

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.

1 · See itKill an agent mid-payment. It does not charge twice.bide demo
2 · BuildA flow with a 2-of-3 approval gate and a test.bide init refund && cd refund && go mod tidy && go run .
3 · ProveVerify the run's evidence offline.bide audit verify-evidence -evidence evidence.json -pubkey keys/log.pub

Recipes 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 →

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

Apache-2.0 licensed.