AI you can replay.

The operational runtime for verifiable AI systems. Every call, tool, and decision is a replayable, tamper-evident event — so trust isn't something your team has to engineer.

The gap

Tracing isn't replay.

Tracing backends reconstruct what your agent did after the fact — valuable, but reconstruction. They can't replay a run deterministically, fork a model decision, or prove a workflow behaves the same way twice. Getting to trust means hiring the team to build it.

Weave's approach

Treat AI calls like database writes.

The runtime records every step to a scroll — an ordered event log. Non-deterministic facts (model responses, tool results) are committed alongside their deterministic consequences. The log is the source of truth. Your agents become systems you can reason about.

What this unlocks

replay

Rerun any call, deterministically.

Feed recorded model responses back into the runtime. Get identical behavior. Your tests become golden files, not mocks.

fork

Simulate the counterfactual.

Edit a recorded response. Rerun from that point. Explore what the agent would have done — without burning tokens on every iteration.

verify

Tamper-evident by default.

Mark a workflow as verifiable and every event is chained to the one before it. Nothing can be changed without it being detectable — so what you replay is provably what happened.

What it looks like

A single ai.Ask call with a local tool handler. The runtime records the entire exchange as a linear event stream on the scroll.

// Your app, in Go.
w, _ := weave.Start(ctx,
    weave.WithProvider("openai", openai.New()),
    weave.WithDefault("openai", openai.GPT5Nano),
)
defer w.Close()

var answer string
_ = ai.Ask(ctx, w, "what is 137 + 488?",
    ai.WithTool("calc",
        "arithmetic on two numbers",
        http.HandlerFunc(calcHandler),
        CalcArgs{},
    ),
    ai.WithResponse(&answer),
)
// answer == "625"
  1. #1 ai.request prompt + "calc" tool schema
  2. #2 ai.response model calls calc(a=137, b=488, op="add")
  3. #3 tool.dispatch publish to the scroll — anyone may handle
  4. #4 tool.result handler returns { result: 625 }
  5. #5 ai.request model gets tool result in message history
  6. #6 ai.response "625"

Events at topic ai.response and tool.result are the non-deterministic commits — the facts weave captures so your system can become deterministic again. Everything else is derived.

Why it works

Trust by construction.

You don't bolt observability, replayability, or verifiability onto an AI system — they're properties of how Weave is built. The scroll is both event store and message bus. Mark a workflow as verifiable and a tamper-evident event chain comes with it. Ship a new tool and it's subscribable, replayable, and auditable by default.

Teams building on Weave don't need a distributed-systems crew to make AI operational. It already is.

Join the early beta.

Weave ships fall 2026. Early access includes design partners who shape the API and get direct support from the team.