Deliberate
log what your agent rejected, not just what it ran
Last verified:
What is Deliberate?
Deliberate is an AI agent decision audit tool that records every option your agent considered, rejected, and executed — providing a complete audit trail you can export, not just a console replay. It captures structured fork logs before tool execution, including rejected alternatives with rejection reasons, the agent's reasoning for its choice, confidence scores, policy violations, and human approval states.
Key features include decision audit trails with fork-by-fork replay, policy gates that block production writes requiring approval, approval workflows for compliance teams, JSONL export format for auditors (one line per fork), and support for irreversible action flagging. The SDK + proxy wraps your agent loop to record forks before execution, working with LangGraph, OpenAI Agents, Cursor, Windsurf, and MCP hosts.
Deliberate is built for teams running LangGraph or OpenAI Agents pipelines in production who need compliance sign-off on AI agent actions. It addresses critical gaps left by trace tools like Langfuse, which show what tool calls ran but not why the agent picked that action or what alternatives were considered. The tool is especially valuable for teams facing the August 2026 EU AI Act logging deadline.
Deliberate pricing
Pricing model: Freemium
Early access pilot in 2026 — SDK available to design partners only. No public pricing published. Integration docs will be shared when cohort starts. Public npm install not yet available.
Deliberate pros
- Records every agent fork — chosen, rejected, and executed
- Captures rejected alternatives with explicit rejection reasons
- Stores agent-stated reasoning on each fork for reviewer evidence
- Policy gates block production writes requiring approval
- Human approval workflows with assignee and pending state
- JSONL export format structured for compliance review
- Fork-by-fork replay after incidents showing policy state
- Confidence scores on forks for triage prioritization
- Blocks irreversible actions until human approval unlocks them
- Works with LangGraph and OpenAI Agents natively
- Supports Cursor and Windsurf MCP host integrations
- Does not require changing existing stack (Langfuse, Datadog, git)
- One JSONL file per run ready for audit export
- Flags tokens read outside task scope before use
- Pauses agent loop at gate with serialized run state
Deliberate cons
- SDK not publicly available as npm install yet — design partners only
- Integration docs not shared until cohort starts
- Confidence scores are not calibrated probabilities
- MCP requires wrapping at runtime layer, not native instrumention
- Early access product as of 2026 — not production-ready for all
- No explicit rollback feature mentioned (only approve/reject)
- Requires agent to emit structured forks (prompting dependency)
- Does not passively read hidden model deliberation
Frequently asked questions about Deliberate
What does Deliberate do?
Deliberate records every option your AI agent considered, rejected, and executed — providing a complete audit trail with fork logs, reasoning, confidence scores, policy violations, and human approval states. It captures structured alternatives before tool execution, not just what ran.
What frameworks does Deliberate support?
Deliberate is built for LangGraph and OpenAI Agents pipelines natively. It also supports Cursor, Windsurf, and other MCP hosts by sitting at the runtime layer where orchestration happens.
How does Deliberate capture rejected alternatives?
For LangGraph and OpenAI Agents, adapters hook the planning step by capturing structured output your agent is prompted to produce: alternatives considered, rejections, and reasons. Deliberate records this fork log before execution runs.
What is the difference between Deliberate and Langfuse?
Langfuse shows tool calls that ran but not why the agent picked that action. Deliberate captures what else was on the table — structured alternatives with rejection reasons, agent reasoning, confidence, safety, and human approval on each fork before execution.
What is a policy gate?
A policy gate blocks production writes requiring approval before irreversible tools run. When triggered, the agent loop pauses, run state is serialized, and human approval is required to unlock execution.
What format are audit exports in?
Audit exports are JSONL files — one line per fork. Each record contains decision_id, task, chosen action, alternatives array with rejection reasons, confidence, policy violations, reasoning, safety, human_approval, outcome, and commit.
When is Deliberate available publicly?
As of 2026, Deliberate is in early access with SDK available only to design partners in the pilot. Public npm install and integration docs will be shared when cohorts start.
What happens while approval is pending?
The agent loop is paused and run state is serialized at the gate. Execution stays blocked until a human approves or rejects — only then does tool execution resume or the run halt.
Does Deliberate work with MCP?
MCP is a tool protocol without a native planning step. Deliberate's adapter sits in your runtime at the orchestration layer (Cursor, Windsurf, IDE-style agent hosts) and logs alternatives considered before execution.
Why does Deliberate matter for EU AI Act compliance?
The EU AI Act logging deadline is August 2026. Deliberate provides structured decision records with audit trails your compliance team can sign off on — meeting logging requirements for AI agent actions in production.