Everything you need for autonomous agent teams.

Work is structured as a directed graph of typed nodes, each with defined inputs, outputs, acceptance criteria, and dependency links. Data dependencies, scheduling dependencies, and decision dependencies are modelled explicitly — not as vague "blocked by" labels.

Sequential by default — predictable, debuggable, safe. Parallel execution is opt-in with --concurrency N, with conservative file-conflict detection and mutex-serialised integration to prevent merge chaos.

Every task declares a responsible role. The orchestrator picks the highest-priority ready task and invokes the appropriate agent. Roles are defined in JSON and fully customisable.

When a task exceeds the revision limit, or an agent flags a decision it can't make autonomously, the orchestrator routes it to the human supervisor — with full context already assembled.

Proposals are typed, not freeform. Each carries a change summary, assumptions made, contracts fulfilled, and a diff of the affected artefacts. Validators receive exactly what they need to make a decision.

The QA agent checks proposals against acceptance criteria and hard gates: failing tests, type errors, missing test coverage. These are binary pass/fail — not vibes. A proposal can't pass if the tests don't.

Rejected proposals go back to the engineer with specific, structured feedback. The agent has up to three rounds to self-correct before the task escalates. This prevents infinite loops whilst still allowing meaningful revision.

Define which change categories require human sign-off: deployments, architectural changes, scope decisions, or anything else. Everything else integrates automatically. The gate policy is version-controlled alongside the project.

Accepted proposals are committed to the Git-backed artefact store automatically. The commit includes full provenance metadata: which agent, which task, which iteration. Downstream dependencies are unblocked immediately.

Context assembly starts by walking the project graph — what does this task depend on? What artefacts does it consume? Structural relevance is determined before semantic similarity. This means agents get the right files, not the most textually similar ones.

Within the structurally relevant set, files are ranked by import relationships, type matches, and explicit file mentions in the task description. Role-aware filtering ensures each agent type gets a context payload optimised for its job.

Hector tracks token budgets per agent invocation and trims context intelligently — prioritising structural relevance, then semantic similarity, then recency. Agents never exceed their context window. They also never receive a truncated context that leaves out critical dependencies.

Relevant architectural decisions and episodic memory are included automatically. Agents don't need to ask "what did we decide about auth?" — the answer is in their context before they start.

Every task execution is logged: the outcome, the number of iterations, which QA issues were raised, what changes were made, and what the final verdict was. Records are stored as append-only JSONL — queryable, inspectable, and version-controlled.

The Retrospective agent distils episodic records into pattern-level insights: which modules tend to cause QA failures, which kinds of tasks the engineer completes first-pass, which approaches consistently succeed. These are surfaced in future context assembly.

After each task, the Retrospective agent writes a short structured reflection — what worked, what would have been faster, what to watch out for in similar work. These compound over time.

Individual memory is private to each agent, covering its personal task history and learned patterns. Team memory is shared across all agents, covering project-level conventions, architectural knowledge, and institutional context.

Architectural decisions are first-class entities: what was decided, why, by whom, what alternatives were considered, and which artefacts and tasks are in scope. The ledger is append-only and immutable. Decisions can be superseded with explicit rationale, but never silently edited.

Each agent role has a defined set of capabilities — which tools it can invoke, which paths it can read or write, which artefact types it can produce. The orchestrator enforces these at invocation time.

File access is validated against role permissions before each operation. Every artefact is integrity-checked with SHA-256 hashing. Tampering is detected immediately.

Every agent action — file access, tool invocation, proposal submission, verdict — is written to a structured audit log. hector security audit gives you a queryable view of everything the system has done.

Enable audit-only mode during initial rollout to observe and log all actions without enforcing capability restrictions. Graduate to enforcement when you're confident in the configuration.

A chat-primary terminal interface built with Bubble Tea. Converse with the PM agent to break down work and create tasks. Toggle a task sidebar with live progress using Ctrl+T. Intervention controls are a keystroke away.

hector run executes the next ready task. hector run --loop executes all ready tasks sequentially. Both are CI/automation-friendly — structured output, non-zero exit on failure.

The companion hector-tools server exposes 8 tools to agent sessions via JSON-RPC: task context, file access, search, decisions, build, test, and more. Agents get a controlled interface to the project — not unrestricted filesystem access.