Stack
v2.0.1 · Open source · MIT

A deterministic contract around stochastic model execution

DAX is a governed execution workstation. It puts policy, approvals, replay and audit around the model, so a coding agent can propose anything and change only what passes.

Local-firstHITL requiredRust proof ladderBun
IntentPolicyApprovalEvidencepropose editASKPOLICYASKthe contract, not the chat
Contract layers

What DAX changes in the run

Govern what changes, keep the trail, and leave evidence, without turning the run into a chat log you have to dig through later.

01

Pause what matters

Risky actions resolve to allow / ask / deny before mutation.

02

See the run

Canonical events and replayable state, not chat archaeology.

03

Prove trust

Audit posture plus tamper-evident ledger checks.

A run does only what was approved

DAX 2.0 adds reviewed runs: the permissions are approved before the run starts, and anything they do not cover is refused on the record. Scroll through one.

  1. Reviewed run

    The run's grant is written down first

    What the run may do, before it starts: which tools, which paths, which agents it may delegate to.

  2. An operator approves exactly that grant

    The approval covers that grant, capability, contract and binding. Remembering it covers only that combination.

  3. Published, activated, then started

    The approved grant is published unchanged, the run is activated against it, and someone starts it. Approval alone does not start a run.

  4. A request outside the grant is refused

    The denial is recorded before any effect. If the decision cannot be recorded, the request is refused as well.

Where everything came from

Delegated tasks, instructions, context and summaries are recorded as commitments, without keeping the conversation text.

A cloned repo runs nothing until trusted

A repository's own tool and plugin files wait for dax trust, and approval is bound to their content.

Built-ins keep their names

A plugin or MCP tool called read cannot stand in for the built-in read under a contract.

Changes over HTTP need a password

Without DAX_SERVER_PASSWORD, the HTTP server is read-only. The local TUI works as before.

Claude through an API key (2.0.1)

Native subscription sign-in is retired. The Claude Code worker keeps its own login.

Reviewed runs cover a compiled DAX binary and remote MCP servers the operator acknowledges. Plugins, local MCP servers, workers and verifiers cannot be bound in a reviewed run, so they are refused there. Details in the changelog.

RAO: intent, run, audit, override

A scripted walkthrough of how DAX pauses risky writes, records a verification receipt, and branches on approve or deny. It runs in your browser; nothing is sent to a server.

Product tour · Scripted demoBeat 0 / 4
Beat 0 · Intent

Task locked before the model moves

write-scope: src/**Forbidden: package.json

Task: Add an isEven helper with tests.

Write-scope is limited to src/**. package.json is forbidden. Policy vocabulary stays exact: allow / ask / deny.

Rust decides deterministic facts

Five crates form the ladder from replay to ledger. Orchestration stays in TypeScript; proofs stay offline and local.

CrateRole
dax-coreReplays canonical run events; deterministic proof reports
dax-policyallow / ask / deny without a model call
dax-auditTrust posture from six structured signals
dax-ledgerTamper-evident append-only chain
dax-indexerDeterministic local structure index
Boundary: TypeScript orchestrates. Rust decides deterministic facts.

Peg note: pinned to commit fe911e57415dcfa9d101bd2584b28d2ea3c84694 (v2.0.1)

Where DAX sits among peers

Same class of tools, different posture on pausing, evidence and replay. As of v2.0.1.

Cursor

  • Strong IDE agent UX
  • Approvals in the editor flow
  • Session-centric trail
  • Less formal audit export

Claude Code

  • Capable terminal agent
  • Permission prompts in-run
  • Transcript-forward history
  • Proof ladder not primary

Codex

  • Cloud / CLI agent loops
  • Policy via product controls
  • Run logs as product surface
  • Local ledger optional

DAX

  • ✓Pause / approval (allow · ask · deny)
  • ✓Evidence-forward diffs
  • ✓Replayable run state
  • ✓Audit readiness + ledger

Get DAX on the machine

Install paths and a local proof-ladder demo. Blocks are copyable; paste into your terminal when ready.

curl
curl -fsSL https://raw.githubusercontent.com/ShaileshRawat1403/dax/main/script/install.sh | DAX_REPO=ShaileshRawat1403/dax bash
brew
brew install ShaileshRawat1403/tap/dax
winget
winget install DaxAi.DAX
demo
bun run demo:proof-ladder

Prefer a release asset? Download v2.0.1.

What the workstation looks like

Screens from DAX 2.0.1, captured from the release binary in a sample repo: the home screen, a worker’s contract before launch, and the connect dialog.

The DAX 2.0 home screen: the DAX wordmark, project, branch and model, the ask box, and quick-start actions to plan a fix, explore the repo or read the docs
Home: project, branch, model and the ask box
The card DAX shows before it launches a governed worker: agent, task, risk, isolation, allowed network hosts, write scope, forbidden paths and the verify command, then Enter to start or Ctrl-C to abort
A worker's contract, shown before it starts
The DAX connect dialog, offering a governed worker that uses a signed-in account and core model providers
Connect a model or a governed worker

MIT. Session data and keys stay local unless you connect a provider. Always review critical actions. HITL required.