Glossary
Agent
A specialized AI worker dispatched by the Conductor to perform a specific role within a sprint. Defiant has 14 agents: captain, architect, navigator, marketer, designer, builder, reviewer, guardian, ambassador, medic, scribe, launcher, counselor, and commander. Each agent has a defined role, a set of skills, and a token budget per dispatch.
Agent authority matrix
The table that defines what each agent can and cannot do: which files it can write, which external services it can call, and which other agents it can invoke. Agents operate within their authority boundary — requests outside it are rejected.
Ambassador
The agent responsible for external API integrations. It implements OAuth flows, webhook registration, and SDK initialization patterns for third-party services (GitHub, Stripe, Sentry, etc.).
Architect
The agent that owns the PLAN state. It produces the technical plan — task breakdown, data model changes, component map, and API contracts — that Builder agents execute.
Artifact
A file, PR, test result, or other output produced by an agent during a sprint. Artifacts are attached to the handoff packet for downstream agents.
Asana PAT
Personal Access Token for the Asana API. Used by the Scribe agent to create and update Asana tasks.
Autogenerate (sidebar)
A Starlight sidebar option that automatically generates navigation entries from all MDX files in a directory. Used for the 14 Agents and Mandate System sections.
Builder
The agent that writes production code. It reads a single task from the technical plan, implements all required files and tests, runs typecheck and lint, commits, and opens a pull request.
Captain
The first agent dispatched on every sprint. It validates the sprint goal, estimates complexity, selects the agent team, and manages the INTAKE and THINK states.
Commander
A meta-agent that coordinates multi-sprint initiatives. It decomposes large goals into sequenced sprints and monitors progress across them.
Completion certificate
A signed JSON artifact produced by an agent at the end of its task. It attests that typecheck passed, tests passed, and no mandate violations remain. The Conductor requires a valid certificate before advancing the sprint state.
Conductor
The local TypeScript daemon that orchestrates everything. It runs the sprint state machine, dispatches agents, maintains the event log, enforces token budgets, and listens for commands via the IPC socket. Started with defiant watch start.
Counselor
The agent that reviews plans and PRs for legal, policy, and terms-of-service compliance. Dispatched for sprints in regulated verticals or those touching payment, health, or user data.
Designer
The agent that produces UI/UX specifications — component hierarchy, interaction flows, accessibility requirements — when a sprint has a UI surface.
Event log
The append-only SQLite database at ~/.defiant/events.db. Every significant Conductor action is written here: state transitions, agent dispatches, mandate checks, PR events. Never modified after write; queried for audit and debugging.
Guardian
The security and compliance audit agent. It runs OWASP Top 10 and STRIDE checks on every PR during the SHIP state, in parallel with the Reviewer.
Handoff packet
The structured JSON object passed from one sprint state to the next. It contains the sprint goal, current plan, prior agent summaries, active mandates, token budget, working directory path, and accumulated artifacts. Each incoming agent reads the handoff packet to understand what has been done and what it must do.
IPC socket
The Unix domain socket at ~/.defiant/ipc/conductor.sock. The CLI, REST API adapter, and MCP server all communicate with the Conductor via JSON-RPC 2.0 over this socket.
Initiative
A large goal that spans multiple sprints. The Commander agent decomposes initiatives into sequenced sprints and monitors their progress.
Inbox
The queue of items requiring human attention. Items are created when an automated gate fails, an ambiguity cannot be resolved, or a mandate requires human decision. Resolved with defiant inbox resolve.
Launcher
The agent responsible for deploying code and confirming production health. It triggers GitHub Actions workflows, creates version tags, runs smoke tests, polls health check endpoints, and triggers rollbacks if health checks fail.
Learning Engine
The local feedback system that observes sprint outcomes and improves future planning. It calibrates task duration estimates, improves agent selection, tracks mandate trigger patterns, and builds a failure pattern library.
Mandate
A YAML rule file in mandate-library/ that defines what agents must and must not do. Mandates have an ID, name, category, severity (blocking/warning/advisory), and one or more rules with check types. Checked at plan time, commit time, and on demand.
Mandate library
The directory of YAML mandate files. Global mandates apply to all projects. Vertical pack mandates are activated when a project uses a specific vertical.
Marketer
The agent that provides market context, user research synthesis, and go-to-market framing during sprint planning. Dispatched when the sprint has a customer-facing dimension.
MCP (Model Context Protocol)
An open protocol for exposing tools to AI models. The @defiant/mcp package exposes five Defiant tools (defiant_sprint_create, defiant_sprint_status, defiant_inbox_list, defiant_inbox_resolve, defiant_projects_list) that Claude can call directly.
Medic
The agent that diagnoses sprint failures and runtime errors. Dispatched when a sprint enters FAILED or when defiant medic is run manually. Produces structured diagnoses and remediation plans.
Navigator
The agent that analyzes dependencies, constraints, and technical risks before the plan is written. Runs during THINK alongside the Captain.
Reviewer
The agent that reviews Builder PRs for correctness, quality, and adherence to the technical plan. Approves and merges passing PRs; blocks and comments on failing ones.
Row-level security (RLS)
A PostgreSQL/Supabase feature that restricts which rows a database query can see based on the authenticated user. Mandate_44 requires RLS on all tables containing user data.
Scribe
The agent that updates documentation, changelogs, and external trackers (Asana, GitHub) when a sprint completes. The last agent in the sprint lifecycle.
Sprint
The primary unit of work in Defiant. A sprint has a goal, a project, a state machine, and an assigned set of agents. Sprints progress from INTAKE through THINK, PLAN, BUILD, SHIP, to COMPLETE.
Sprint state machine
The formal state machine that governs sprint progression: INTAKE → THINK → PLAN → BUILD → SHIP → COMPLETE. Any state can transition to BLOCKED (gate failure) or FAILED (unrecoverable error). State transitions are atomic and logged.
STRIDE
A threat modeling framework: Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service, Elevation of Privilege. Applied by the Guardian agent during SHIP.
Task
A single implementable unit of work within a sprint, produced by the Architect’s technical plan. Each task has a description, file list, acceptance criteria, assigned agent, and estimated token cost.
Technical plan
The Architect’s output from the PLAN state. It contains a list of tasks, schema migrations, component specifications, API contracts, and a mandate compliance report.
Token budget
The limit on how many tokens agents can consume. Two limits apply: 200,000 tokens per task (per Builder dispatch), and 2,000,000 tokens per day (across all sprints). Four throttle states: green (> 1M remaining), yellow (500k-1M), orange (100k-500k), red (< 100k).
Turbo
The build system used by the Defiant monorepo (pnpm turbo). Runs typecheck, lint, test, and build tasks in parallel across packages with caching.
Vertical pack
A bundle of mandates tailored to a specific business model or regulated industry. One of: solo-founder, b2b-saas, marketplace, fintech, healthcare, pe-portfolio. Activated when a project is created with --vertical.
Worktree
A git worktree — a separate working directory linked to the same git repository. Each sprint runs in its own worktree at ~/.defiant/worktrees/<sprint-id>/, providing isolation so multiple sprints can run in parallel without interfering with each other or with the main branch.