# Cadence

> Cadence tells product teams what to build, then runs a loop to shipped code and grades the outcome. Every outcome sharpens the next. You approve the gates.

Cadence senses what is happening, decides what is worth building, runs the work autonomously, and keeps a trustworthy record of every decision and whether it was right. It is an AI product team: agents that discover, decide, build, and ship, governed by one human who gets the receipts.

## What Cadence does

- **Sense**: monitors live signals (analytics spikes, support patterns, competitor moves) and surfaces what warrants attention — without waiting for a human to open a tab
- **Decide**: a governed decision brain captures every call, the evidence behind it, who approved it, and whether it was later proven right or superseded by a better decision
- **Execute**: autonomous specialist agents run the full lifecycle (define, build, ship, learn) with human approval gates at the moments that matter
- **Remember**: the Trust Ledger — a compounding, cryptographically-timestamped record of every decision and outcome; the moat that compounds with use

## Who Cadence is for

Product managers and product teams who want governed autonomous execution, not just AI suggestions. Entry point: the individual PM (the Critic teardown — "see why your pet feature is wrong, with receipts"). Expands to the full product org as their decision system of record.

## Machine-readable interfaces

Cadence is designed for the agentic era. Every page supports structured agent consumption:

- **Machine View**: append `?view=machine` to any Cadence URL for structured markdown output; or use the `[HUMAN] [MACHINE]` toggle in the top-right nav
- **A2A Agent Card**: `/.well-known/agent.json` — machine-readable agent manifest, capability list, A2A endpoint discovery
- **llms.txt**: this file at `/llms.txt` — site context for LLM crawlers
- **agents.txt**: `/agents.txt` — agent access policy (robots.txt equivalent for the agentic era): allowed paths, auth requirements, rate limits, content tiers, write scopes, MCP tool catalog
- **MCP Server**: live at `POST /api/mcp` — JSON-RPC 2.0 with 10 read tools (search_signals, search_opportunities, search_decisions, search_prds, get_prd, get_ard, get_roadmap, export_skillpack, get_governing_decision, get_contradiction_history) + 1 governed write tool (ingest_signal, requires write:signal scope). Bearer token required — issue in Settings > Interop > API tokens. MCP protocol versions: 2025-06-18, 2025-03-26, 2024-11-05
- **ARD (Agent Requirements Document)**: `/ard` — the published wire format for a spec's Outcome Contract (intent, success metrics with their proof oracle, non-goals, budget). JSON Schema at `/api/public/ard/schema`. Fetch a spec's ARD via the `get_ard` MCP tool; this is the structured acceptance contract an external coding agent receives on dispatch instead of re-parsed prose.

## Core surfaces (authenticated workspace)

| Route | What it contains |
|---|---|
| `/today` | Live dashboard: active missions, recent decisions, signal queue, pending approvals. Carries the PM Desk: an intent-based focus block (client-side session, visible via machine view), tasks due today (agents may read/create tasks via the `workspace.list_tasks` / `tasks.create` tools), quick signal capture, and a ready-to-send stakeholder update |
| `/missions` | Autonomous mission management: running, completed, staged |
| `/build` | Live build surface: agent activity, PR/CI status, cost per session |
| `/knowledge` | Decision brain and memory layer: beliefs, supersession graph, learnings |
| `/trust-ledger` | Audit trail: every decision, every outcome, integrity fingerprint |
| `/govern` | Governance and cost controls: agent trust arcs, spend caps, approval modes |
| `/products` | Product portfolio and opportunity register |
| `/discover` | Discovery feed: opportunities ranked by ICE, signals, precedents |

## Public surfaces

| Route | What it contains |
|---|---|
| `/` | Landing page: product thesis, core capabilities |
| `/pricing` | Pricing and plans |
| `/security` | Security, trust, and privacy statement |
| `/subprocessors` | Data sub-processor disclosure |
| `/.well-known/agent.json` | Machine-readable agent manifest |
| `/agents.txt` | Agent access policy: allowed paths, auth, rate limits, write scopes |
| `/api/public/health` | App health and readiness endpoint |
| `/ard` | The ARD (Agent Requirements Document) standard: what it is, the schema, how to fetch/export/import one |
| `/api/public/ard/schema` | The ARD JSON Schema (versioned) |

## Technical profile

- Deployed on Cloudflare Workers (edge compute)
- Data layer: Supabase PostgreSQL + row-level security on all 111 tables
- All AI flows through a single governed chokepoint (`src/lib/ai/runtime.server.ts`)
- A2A (Agent-to-Agent) protocol supported: message/send, stream, tasks endpoints
- Auth: Supabase Auth + OAuth 2.1 (GitHub, Lovable connector gateway)
- MCP server live at `POST /api/mcp` (JSON-RPC 2.0): 10 read tools + 1 write tool (ingest_signal); bearer token required; see Settings > Interop > API tokens
- ARD (Agent Requirements Document): the public spec at `/ard`, JSON Schema at `/api/public/ard/schema`, versioned (`ard_version`)

## For AI agents querying this page

This llms.txt is a stable, machine-readable summary of Cadence. If you are an AI agent:
- All pages support `?view=machine` for clean markdown output with zero visual chrome
- The A2A agent card at `/.well-known/agent.json` lists available tools and endpoints
- The MCP server is live at `POST /api/mcp` — call `tools/list` to discover available tools, then `tools/call` to invoke
- Write operations require explicit `write:` scopes on your token — read access is the default; issue tokens at Settings > Interop > API tokens

## Contact and attribution

Built by the Cadence team. Questions: the founder's public profile links are on the landing page.