Most agents write code. Excalibur knows the whole product cycle — discover, build, verify, ship.
›Add rate limiting to the public API
L4 — Full agentic · kimi-k2.7-code
⠋Implementapi/limiter.ts
│└ edit api/limiter.ts+38 −4
│└ ▸ pnpm test apirunning…
│
████░░░░1m12s·$0.42·standard-safe·no push
With Excalibur you can:
Time-travel your work·Discover what to build·Run it from a local board
01What you can do
Five capabilities built right into the engine — the moats that hold up against any other AI coding tool.
the immutable event log
Every run is an immutable, append-only event log — so you scrub it like a video and branch a new run from any step. The stream IS the run: it renders the live view, the replay, the dashboard and the audit trail, byte-identical. Nobody else is built this way.
step 06 / 14 · Implement+38 −4
planimplementtests failreview
live = replay = dashboard = audit · one immutable stream
the gate no one else has
Before a line of code, Discovery weighs scope, evidence and risk — and recommends build, validate, or don’t-build.
discovery · add AI invoice summaries
clarity
evidence
scope
risk
readiness
recommendation: needs_validation
→ thin evidence — validate with 3 design partners first · work item WI-142
local · no SaaS
“excalibur serve” opens a task-first web dashboard — embedded in the CLI, one local process, no account. It’s that same event log, rendered for the browser. Terminal-only tools don’t have this.
dashboard · localhost:7878
backlog
WI-140 · webhook retries
running
WI-142 · invoice AI ◐
$2.40 today · 3 runs · live chronogram ▸▸▹ · share ↗ read-only
no lock-in
Excalibur isn’t wired to one vendor — OpenAI-compatible (incl. Azure), Anthropic, Ollama and more. Pick a good + fast pair with a single key and switch anytime.
●claude-opus-4good · default
○gpt-4o
○llama-3.3-70bfast · paired
○ollama/qwenlocal
good + fast from one key · no vendor lock-in
not just the diff
Most agents write code. Excalibur owns the bookends too — deciding what to build up front, then proving and auditing what shipped at the end.
workflow · standard-feature
Discover→
Plan→
Build→
Test ⛬→
Docs ⛬→
Review→
Ship→
Audit
→ sized to 3 agents — independent modules, isolated worktrees
✓ verification mesh · tests_passed · type_safe · no_secrets
All five — free, open-source, one npm install away.
For developers
02The whole cycle
Chatbots autocomplete. Coding agents build and ship. Excalibur runs the entire cycle — deciding what to build up front, and auditing what shipped at the end — and it’s fully open source.
DiscoverPlanBuildTestDocumentReviewShipAudit
Excalibur
Coding agents
Coding agents take you from plan to ship. Excalibur owns the bookends too — deciding what’s worth building, and auditing what shipped.
Discovery clarifies scope first — and can recommend not building it. Most tools start at the code.
Every run plans, implements, tests and documents the change — tests and serious docs are phases, not afterthoughts.
Pull requests, approvals and a full audit trail — not just a diff in your editor.
Every step configurableEvery action traceableEvery risky op approved
For developers
03Quickstart
Install, run it in any repo, and start building — the first run sets itself up; then an agent plans, implements, tests and documents real changes in an isolated branch.
Install · one binary, local-first
Run excalibur · first run detects your stack & connects a model
Describe a task · an agent plans, builds, tests & ships it
Apache-2.0
For developers
04What Excalibur does
Express intent — Excalibur picks the workflow and sizes the work. Dial it per task, from a quick answer to a fully agentic run.
less autonomymore autonomy
L0Reviewreview
L1Assistask
L2Propose patchpatch
L3Implement in branchrun
L4Full agenticrun --careful
Eleven ways to put agents to work
01run
An agent builds the whole change in an isolated branch.
02run --careful
A ticket becomes a plan the agent runs once you approve.
03discovery
An agent clarifies scope first — it can say don’t build it.
04swarm
Fan a task out to parallel agents — verified against your tests before the merge.
05review
Review the agent’s changes before they ship.
06patch
Get a small, reviewable patch from an agent.
07ask
Understand any codebase before you build.
08research
Agents fetch and search the live web — governed, with citations.
09serve
A local web board: kanban, runs, cost charts, live orchestration.
10schedule
Run agent tasks on a cadence — every N, or daily at a time.
11.excalibur/
Every agent run kept auditable, as local files.
05Built-in workflows
Opinionated recipes for how serious teams ship — 14 workflows and 14 methodologies, ready on day one.
Anatomy of a run
Plan
Scope the change first
Implement
Write the code in an isolated branch
Verifygate
Tests must pass to continue
Documentgate
ADRs, API docs & changelog
Review
An adversarial second pass
Pull request
Opened for a human to merge
Tests and serious docs aren’t an afterthought — they’re phases.
01
Read and critique before touching a line.
02
Small, obvious fixes — minimal ceremony.
03
The everyday plan → build → test → ship.
04
Bigger work with specs, gates and approvals.
05
Behaviour-preserving, with tests as the net.
06
Threat-aware build with a security gate.
07
Staged, reversible, data-aware changes.
08
Several approaches in parallel — compare and pick.
09
Decide what to build — or whether to build at all.
Use the defaults today. Customize every phase, gate and role in YAML tomorrow.
Browse the catalog06Safe by default
Delegate big work without fear. Nothing is modified, applied or pushed without your explicit approval — standard-safe is on from the first command.
One keystroke decides — approve, reject, or allow it always. Risky operations always wait for you.
Every write, command and push pauses for an explicit yes.
Agents run in an isolated sandbox — no network access by default.
.env files and private keys are blocked — never read or sent.
Work lands in dedicated branches — never your working tree.
Inputs are scrubbed of secrets before anything is stored.
Every action is logged as plain local files you can audit.
For teams & managers
07Excalibur Enterprise
The control plane for AI engineering — give every developer agents, with the visibility, policy and proof to run it safely across the whole org.
Preview of the Enterprise control plane (in development). The OSS excalibur serve dashboard ships locally today — see Core.
Why leadership says yes
Cost, time, usage and quality across the fleet — rolled up org → team → repo, with budgets and forecasts.
A policy engine, model governance and SSO/SCIM, with an audit trail that exports to your SIEM.
Every run’s claims — tests, types, no secrets — roll up into a signed compliance pack.
Decisions and earned autonomy build up across the org — and survive turnover.
Agentic-agile planning, a native kanban (Linear / Jira sync planned), and approvals from your phone.
Hybrid or fully self-hosted runners — your code never leaves your infra. Air-gapped if you need it.
08Core vs Enterprise
Everything a developer needs — safe by default — is open-source. Teams add governance, compliance and control.
| Capability | Core | Ent |
|---|---|---|
| Interactive m-shell + CLI | Included | Included |
| Any model, any provider (in-shell /models picker) | Included | Included |
| Autonomy levels (L0–L4, L4 default) | Included | Included |
| Built-in workflows & methodologies | Included | Included |
| Discovery — decide before you build | Included | Included |
| Plan-shaping — co-create the plan first | Included | Included |
| Time machine — rewind & fork runs | Included | Included |
| Self-sizing swarm + Explore (best-of-N) | Included | Included |
| Verified fan-in + live wave/DAG chronogram | Included | Included |
| Autonomous loop, background fleet & scheduler | Included | Included |
| Web access & research (fetch · search · crawl) | Included | Included |
| Context compaction | Included | Included |
| Memory that compounds | Local | Org |
| Local dashboard + fleet view | Included | Included |
| Local work items & kanban | Included | Included |
| IDE extension (VS Code · Cursor · Windsurf) | Included | Included |
| Capability | Core | Ent |
|---|---|---|
| Custom agents (Markdown personas) | Included | Included |
| MCP · LSP auto-install · auto-format · SDK | Included | Included |
| Works with CLAUDE.md / AGENTS.md | Included | Included |
| Safe by default — approvals + secrets blocked | Included | Included |
| Sandboxed execution (no network by default) | Included | Included |
| Verifiable claims — tests · types · no secrets | Included | Included |
| Work-item sync (Linear · Jira · …) | Not included | Included |
| Agentic-agile (daily / weekly) | Not included | Included |
| SSO / SCIM · RBAC · multi-tenant | Not included | Included |
| Policy engine + budgets | Local | Org |
| Claim Ledger → Compliance Pack | Not included | Included |
| Insights & ROI (5 lenses) | Not included | Included |
| Audit & cost visibility | Local | Org |
| Hybrid / self-hosted runners | Not included | Included |
| Mobile approval / remote | Not included | Included |
| Support / SLA | Community | Included |
For developers
09Extensible by design
Customize with simple YAML — or go deeper with the TypeScript SDK, MCP servers and LSP diagnostics.
YAML / Markdownno code
methodologiesworkflowsquestion packspromptssafety presetsmodel routing
TypeScript SDKcode
work-item providerschannelsMCP serversmodel providersagent adapterstoolspolicy evaluators
Plus first-class MCP servers, LSP diagnostics, custom agent personas, and an IDE extension for VS Code / Cursor / Windsurf — all built in.
SDK on npm · no glue code
For developers
10For product engineers
A product engineer owns the outcome, not just the output — deciding what to build, shipping it, and knowing where everything stands. Here is what that looks like when your agent runs the whole cycle.
9:02
“Could billing retry itself?” The discovery gate scores it — problem clarity, evidence, scope, risk — and says: build.
9:05
You describe it in plain words. The plan appears as work items on the board, dependency-linked, attached to this week’s sprint.
9:07
Three workstreams run in parallel, each in its own isolated git worktree. You watch the lanes fill live from the card in your browser.
9:19
Nothing lands until your real tests pass and an adversarial review finds nothing high-severity. You approve the gate looking at the diff.
9:20
Cards slide to done. The burndown ticks. Nobody updated a ticket — the backlog wrote itself.
9:21
Why you built it this way is captured with the files it touched. The next build on that code starts already knowing.
That was one morning. The unit of work was never the prompt — it was the product.
Open-source · Enterprise-ready
Start with Excalibur Core on your machine. Bring the workflows, policies and visibility your organization needs with Excalibur Enterprise.
Not ready to install? Get the launch updates — no noise, only ships.
Developers want power. Companies need safety. Excalibur gives both.