Delano

Your agent says it's done. Prove it.

Delano is a delivery runtime for coding agents. Specs, plans, tasks, and evidence live as files in your repo. Any agent can execute them. Anyone can verify them.

Read the handbook

Works with ChatGPT, Codex, Claude Code, Claude, and whatever ships next. No account. No cloud. No lock-in.

delano WORKSPACE Context pack 12 Projects 3 Open work 9 Progress 14 Annotations 1 Validation 58 Warnings 0 Blockers 0 SELECTED PROJECT Relay Stage 1: Foundat Project overview SOURCE CONTRACTS Spec Plan Decisions Workstreams 6 WS-AArchitecture and Storage WS-BIdentity and Tenancy WS-CMessaging Domain WS-DRealtime and Async Tasks 14 T-001Define message envelope T-002Transactional outbox T-003Ordered, idempotent sends Relay Stage 1: Foundation Active Last updated 10 jul 2026, 23:51 Activity Open in IDE CONTENTS Spec: Relay Stage 1: Foundati... Executive Summary Problem and Users Outcome and Success Metr... User Stories Acceptance Scenarios Scope In Scope Out of Scope Functional Requirements Assumptions Hypotheses and Unknowns Probe Findings Dependencies Approval Notes Back Edit Review 0 Send to ChatGPT Document details Path, status, title, and baseline PATH STATUS UPDATED BASELINE projects/relay-stage-1/spec.md active 10 jul, 23:51 a828dd7620 Spec: Relay Stage 1: Foundation Executive Summary Stage 1 establishes the smallest usable Relay: two humans and one external agent collaborate in one workspace through ordered, durable, permission- aware messaging. It proves the identity model, accountable agent ownership, shared authorization, and the transactional outbox before later collaboration features are added. Problem and Users Agent-heavy software teams currently connect software colleagues through webhooks, shared tokens, copied context, and cron output. Those patterns obscure ownership, permissions, identity, and recovery. Stage 1 serves an internal workspace and invited design-partner operators who need a trustworthy human/agent conversation core. Outcome and Success Metrics Two browsers and one external agent exchange ordered messages reliably in one workspace, and every claim of progress leaves a dated, checkable line.

Runs with the agents you already use.

ChatGPT Codex Claude Code Claude T3 Code
Why
Why Delano

Chat is where delivery goes to die.

Coding agents produce working code in minutes. Then the session ends, and everything that made the work trustworthy disappears with it. The plan lived in a prompt. The decisions lived in scrollback. The proof that tests passed lived in the agent's memory, which is to say: nowhere.

The next session starts from zero. A second agent can't pick up where the first one stopped. You can't audit what happened last week. And "it's done" means whatever the agent decided it means.

The hard part was never getting an agent to write code. It's knowing what was agreed, what was built, and what was verified, three weeks later, by someone who wasn't in the chat.

Before

  • Plans and decisions live in chat sessions that expire
  • Every agent session starts without context
  • "Done" is a claim, not a checked state
  • Switching agents means starting over

After

  • Specs, plans, tasks, and decisions are files in .project/
  • Any agent reads the same contracts and continues the work
  • Tasks close only with acceptance criteria met and evidence recorded
  • delano validate fails loudly when contracts and reality drift

Files define truth. Tools execute against files. Everything else follows from that one sentence.

Way of working

One flow for every project: outcome, spec, probe decision, plan, workstreams, tasks, evidence, learnings. Each step is a markdown file you can read, diff, and review.

CLI

A thin command line that installs the runtime, reads state, and wraps the scripts that do the real work. Everything supports --json. It never phones home.

Skills

Ten lifecycle skills, from discovery to learning. Each one is a contract with required inputs, an output schema, and quality checks, so different agents decompose work the same way.

Rules & evidence

Every rule carries an honest label: enforced, policy, or guidance. Done tasks need checked criteria plus recorded proof, and the validator fails loudly when either is missing.

Model
How it works

Contracts over tools.

Delano's core idea fits in one sentence: files define truth, tools execute against files. Every project follows the same flow, and each step is a markdown file in your repo. You can read it, diff it, review it, and version it like everything else you ship.

Outcome→Spec→Probe decision→Plan→Workstreams→Tasks→Evidence→Learnings
Relay Stage 1: Foundation Active spec.md projects/relay-stage-1/spec.md --- id: relay-stage-1-foundation status: approved operating_mode: uncertain-feature probe_required: true probe_decision: run-probe # recorded 2026-07-08 --- Hypotheses and Unknowns Ordered delivery under concurrent sends is the one approach we could not call proven. The probe decision below puts that uncertainty on record instead of hiding it inside an estimate. Probe Findings Sequence numbers stay unique under 200 concurrent sends. Retrying a send returns the original result. No duplicates observed. Probe retired the ordering risk in one day. Spec approved the next. Skipping the probe is allowed. Skipping it silently is not.

The probe decision

Before a spec gets approved, Delano forces one explicit choice: is this approach proven, or does it need a small prototype first? Skipping the probe is allowed. Skipping it silently is not. The decision goes on record either way.

Evidence

An agent claiming a task is done counts for nothing. Done means the acceptance criteria are checked and the evidence log shows what ran, what passed, and where the proof lives. An agent that closes a task without evidence fails the gate.

CLI
The CLI

Ten commands. All of them boring on purpose.

The CLI is deliberately thin. It installs the runtime, reads state, and wraps the scripts that do the real work. It never phones home.

npm install -g @bvdm/delano       # once, anywhere
delano install --yes              # inside your repo
delano validate                   # do contracts and reality still agree?
delano status --open --brief      # what's in flight
delano next                       # dependency-safe next task
delano init my-feature "My Feature"
delano research my-feature open-question
delano task close my-feature T-001 --evidence "tests pass, see updates/003"

Made for agents too

Everything supports --json, because half your users are agents parsing the output.

Conflict-first install

Install computes the full plan, aborts on any existing file, and only overwrites with an explicit --force. Your repo state stays yours.

Skills
Skills

Agents don't memorize your process. They read it.

Delano ships ten skills that cover the delivery lifecycle: discovery, research, prototype, planning, breakdown, execution, quality, sync, closeout, and learning.

A skill is not a prompt trick. It's a contract: trigger context, required inputs, output schema, quality checks, failure behavior, and allowed side effects. When an agent breaks a plan into tasks, the breakdown skill defines what a valid task looks like, and validation checks that it produced one.

The result: a Claude Code session and a Codex session decompose work the same way, because they follow the same file, not the same vibes.

Same file, any agent

Skills live in .agents/skills/ and are mirrored to each agent's native format. One source of truth, no per-agent drift.

Checked, not hoped

Skill outputs land in contract files, so the validator can tell whether a skill actually produced what its schema promises.

Evidence
Rules and evidence

Three kinds of rules, and the honest label on each.

Most process documents pretend every rule is enforced. Delano tags each one.

[enforced]

A validator checks it

Violations fail delano validate. These are the mechanical guarantees.

[policy]

The handbook requires it

Humans verify it, until a validator exists. Every policy rule is an open candidate for enforcement, and the list shrinks over time.

[guidance]

Recommended

Deviate freely. That honesty is the point: you always know which guarantees are mechanical and which depend on discipline.

Evidence works the same way. Done tasks need checked acceptance criteria plus recorded proof: what was implemented, which validation ran, where the results live. Failures don't get hidden. They get logged in the task, then fixed.

The task detail page in the viewer: title first, quiet collapsible detail cards, and checked acceptance criteria
[enforced] delano validate evidence present · criteria checked 6/6
Viewer
The viewer

Review the work. Then hand it back.

delano viewer opens a local, guarded review surface at 127.0.0.1. It reads your .project files and shows specs, plans, workstreams, tasks, and their dependencies as one navigable dossier.

Select any text and annotate it: a comment, a question, a verify request. Then hand the bundle to an agent with one click. The viewer writes a handover file and opens Codex or Claude Code with the exact feedback, scoped to the exact contract.

The same button works for dispatch. Point at a task, choose "start the work" or "review delivered work", and the agent gets the contract file, the acceptance criteria, and the instruction to record evidence before closing.

Annotating in the viewer: a highlighted sentence in the spec with the popover open, showing the quote, comment, question, and verify tabs, and a save action
The send-to menu in the viewer: choose ChatGPT, Codex, Claude Code, Claude, or a custom agent, send for review, or copy a handover command

A reading room, not a control panel

The viewer never edits canonical files behind your back. Annotations live in their own store, and markdown changes require a diff preview and explicit confirmation.

Start

One command. Your repo. Nothing else.

npm install -g @bvdm/delano
delano install --yes
delano viewer
Read the first-15-minutes guide

Fifteen minutes from a plain idea to a validated project with a spec, a plan, tasks with acceptance criteria, and a gate that keeps everyone honest.

Delano is open source, local-first, and agent-agnostic. The files are yours. The truth is in them.