Approval-Gated AI Code Execution Control Plane

Delivered with guarantees,not promises.

Syndicate Code is a governed execution control plane that enforces approval boundaries, generates attributable evidence, and binds decisions to executed actions. No untracked side effects. No ambiguous approvals. No incident-response blind spots.

Download + Run Read AI Governance

syndicate

Single binary

exit 2

Headless checkpoint block

SQLite WAL

Local control DB

Governed sessionoperator checkpoint

▌

$ syndicate run --objective "upgrade dependency" --checkpoint always

How this operates

Six enforcement points. No silent side effects.

Proposal — Structured action request from the runtime

Canonicalization — Normalized arguments bound to the approval

Policy evaluation — Capability rules applied; deny/checkpoint/allow decision recorded

Checkpoint — Operator approval captured with execution context

Permit — Time-bounded execution token issued

Evidence — Append-only chain records exactly what executed, under which permit

The control plane is authoritative. The runtime is non-authoritative. Decisions are attributable. Every approval event can be traced to a specific identity, policy version, and execution context.

Works alongside enterprise AI platforms

The execution layer your AI platform doesn't cover.

Enterprise AI platforms govern which agents and models your teams can use. Syndicate Code governs what those approved agents are permitted to execute at the moment of action, inside the developer's environment. Policy-gated tool calls, operator approval checkpoints, and a local audit chain that answers: who approved the exact action that ran?

This site was built under Syndicate Code governance. The approval records, policy decisions, and audit events from its development are committed to the repository.

Control plane capabilities

Built for attributable execution, not chat convenience

Full capability model

Ground-Up Runtime

Current execution engine is a greenfield rebuild. Legacy action handlers and orchestration paths were retired.

Policy-First Execution

Every action request passes capability policy checks before side effects. Governance is enforced at execution boundaries.

Operator Checkpoints

Side-effecting operations can require explicit operator decisions with bound execution context.

Provider Flexibility

Model/provider integration is handled behind control-plane policy instead of hardcoded coupling to one vendor path.

CLI/TUI Workflow

Terminal-native workflow for operators, with non-interactive execution for automation and CI pipelines.

Rebuild-Aligned Contracts

Public behavior is now documented against the rebuilt control plane, not historical implementation details.

Execution path

Six stages. No silent side effects.

Proposal - Runtime submits structured action proposal.

Canonicalization - Control plane normalizes arguments.

Policy - Capability rules decide deny/checkpoint/allow.

Checkpoint - Operator approves or rejects.

Permit - Time-bounded permit is issued.

Execution + Audit - Action executes with attributable evidence.

Install flow

1. Install `syndicate`

One command. No dependencies. Runs on macOS, Linux, and Windows.

# macOS / Linux
curl -fsSL https://install.syndicatecode.ca/install.sh | bash

# Windows (PowerShell)
irm https://install.syndicatecode.ca/install.ps1 | iex

2. Verify binary

Confirm version/build metadata and runtime availability.

./syndicate --version

3. Run governed workflow

Use interactive or headless mode with checkpoint semantics.

./syndicate
./syndicate run --no-tui

Local execution control

Run the binary. Keep control.

Syndicate Code is free to run. No license required for individual use. Governed execution with attributable evidence. No vendor dependency.

Get Started Model Constraints