Specialised roles. Shared goal.

Hector ships with seven built-in agent roles, each with a defined scope, capability set, and system prompt template. New roles can be added as JSON files in .hector/roles/.

PM
Product Manager

Owns the brief. Takes the initial input, decomposes it into structured requirements, manages the backlog, and communicates with the human supervisor.

PLANNER
Planner

Decomposes complex work into independently executable subtasks, each sized to complete within token and timeout budgets.

ENGINEER
Engineer

Writes, tests, and documents code. Works in a Claude Code session with file access, iterating with tools before submitting a structured proposal.

QA
QA Agent

Reviews proposals against acceptance criteria and hard gates — failing tests, type errors, missing coverage. Returns a typed verdict: accept, reject with feedback, or escalate.

DESIGNER
Designer

Owns information architecture, UI/UX decisions, component specifications, and design tokens. Produces structured artefacts consumed by the Engineer.

DEVOPS
DevOps

Manages build pipelines, infrastructure provisioning, monitoring, and deployment. Handles the "ship" part of "build and ship."

RETRO
Retrospective

After each task, captures what worked and what didn't into episodic memory. Distils pattern-level insights to feed into future context assembly.

+
Add custom roles via .hector/roles/

Five stages, machine speed.

The orchestrator drives this loop continuously, picking the highest-priority ready task, assembling context, invoking the right agent, and processing the result.

01 · PLAN
Decompose

The PM agent takes the brief. The Planner agent breaks complex work into independently executable subtasks, each with acceptance criteria and typed dependencies.

02 · EXECUTE
Implement

The Engineer agent receives a tailored context payload — relevant files, decisions, and artefacts — and works with full tool access: read, write, build, test.

03 · VALIDATE
Review

The QA agent receives the proposal and checks it against acceptance criteria and hard gates. It returns a structured verdict with specific, actionable feedback.

04 · NEGOTIATE
Revise or escalate

Rejected proposals go back to the Engineer with QA's feedback. Up to three revision rounds are allowed. On the fourth failure, the task escalates to a human supervisor.

05 · INTEGRATE
Commit & learn

Accepted proposals are committed to the Git-backed artefact store. Downstream dependencies are unblocked. The Retrospective agent captures what happened into episodic memory.

negotiation protocol · task implement-auth-middleware
Engineer → QA [proposal, iter 1] changes: 3 files, +142 -8 lines QA → Eng [REJECT] error: missing auth header validation on /api/v2/upload   Engineer → QA [proposal, iter 2] changes: 3 files, +159 -8 lines QA → Eng [REJECT] error: token expiry not tested; test coverage 61% < 80% gate   Engineer → QA [proposal, iter 3] changes: 4 files, +201 -8 lines QA → Orch [ACCEPT] tests: 12 passing, coverage 84%   ✓ Integrated. Commit 4f2a8d9. Downstream tasks unblocked: 2.

Seven primitives. One coherent platform.

These are the building blocks that make autonomous agent collaboration reliable. Each solves a specific coordination problem that existing tools leave to you.

Project Graph
Replaces: repository + issue tracker. The central data structure is a directed graph of typed work units. Each node carries inputs required, outputs produced, responsible role, acceptance criteria, and typed dependency links — data dependencies, scheduling dependencies, and decision dependencies. The orchestrator walks this graph to schedule work. Agents query it to understand their task. Humans view it to track progress.
Artefact Store
Replaces: the file system / Git tree. Every output is a typed artefact with a schema, version history, provenance (which agent, which task), and tracked consumers. When an upstream spec is updated, the platform knows exactly which downstream artefacts may be invalidated — and which agents need to be notified. Git semantics are preserved internally; the codebase sits within the broader artefact model as one type among many.
Context Assembler
Entirely new. When an agent is invoked, the platform assembles its context window automatically: walking the project graph for dependencies, querying the agent's episodic memory, loading the role definition, and fetching recent relevant events — all budgeted against the token limit. Relevance is determined by structural dependency first, then semantic similarity, then recency. This is what makes the system efficient.
Negotiation Protocol
Replaces: pull requests and code review. Propose–validate–integrate runs at machine speed. An agent submits a proposal with structured metadata. Validators return typed verdicts: accept, reject with specific reasons, or accept with conditions. Accepted changes integrate automatically. Rejected changes return to the producer with structured feedback. Human review is an optional escalation for high-stakes changes — not a bottleneck on every change.
Event Mesh
Replaces: webhooks and notifications. Every state change — artefact updated, task completed, validation failed, decision recorded — is a typed event. Agents declare interests at a fine-grained level. Events can trigger agent invocations with context pre-assembled, making the system reactive rather than poll-based. The orchestrator uses the event stream to detect anomalies, bottlenecks, and conflicts across the entire project.
Decision Ledger
Replaces: ADRs and meeting notes. Decisions are first-class entities: what was decided, why, by whom, what alternatives were considered, and which artefacts and tasks are in scope. They are linked to the project graph and surfaced automatically in agent context. The ledger is append-only and immutable — decisions can be superseded by new decisions with explicit rationale, but never silently edited. Agents stop re-debating settled questions.
Agent Identity & Memory
Entirely new. Each agent has a persistent identity: a role definition, configuration, and episodic memory — a structured, searchable log of past task executions. Memory has two scopes: individual (private, covering personal task history and learned patterns) and team (shared, covering project-level knowledge and conventions). The platform manages storage, compression, and retrieval. Agents improve over time at the specific kinds of work they do repeatedly.
CLI / TUI
Orchestrator ──── Project Graph (tasks, deps, status)
├── Context Assembler (relevance scoring, caching)
├── Agent Runtime (Claude Code CLI / API)
│ └── MCP Server (hector-tools, 8 task-scoped tools)
├── Negotiation Protocol (validate → accept / reject / escalate)
├── Artefact Store (Git-backed, typed, versioned)
├── Memory System (episodic, pattern, reflection)
├── Decision Ledger
├── Security (role capabilities, path validation, audit)
└── Event Mesh (in-process pub/sub)

Ready to try Hector?

Join the waitlist and we'll reach out when early access opens.

You're on the list.