Headcount:1

Run your company from a town of AI agents. Approve the plan, follow the handoffs, and open the finished work.

Comment

Headcount: 1

Inspiration

AI makes individual tasks easier to delegate. Running a business still requires someone to connect those tasks: establish dependencies, transfer context, evaluate outputs and resolve conflicting assumptions. For a solo operator, that coordination becomes a second workload.

Headcount: 1 explores a different operating model: one person directing a coordinated AI workforce. The central problem is execution across multiple models, asynchronous services and successive revisions while maintaining a coherent objective. I built the orchestration infrastructure needed to make that collaboration inspectable and useful.

What it does

Headcount: 1 converts a high-level business objective into a structured execution plan. After human approval, it dispatches work, propagates accepted context between dependent tasks, coordinates parallel execution and evaluates deliverables through a review-and-revision loop. The result is a connected package of research, web assets, launch materials and a consolidated brief.

This supports research-led business workflows such as venture exploration, positioning, concept validation and go-to-market preparation. A founder, independent consultant or small team can use the same underlying process to move from an ambiguous objective toward concrete, reviewable outputs.

The default configuration uses three specialist agents, coordinated by a separate planning and review layer. This creates a focused working group with explicit responsibilities and shared deliverable contracts. Expanding that group is part of the architecture's development path: additional agents would register their capabilities, input requirements and output schemas with the executor. The current release implements the three-worker configuration.

Human-in-the-loop governance remains part of execution. The operator approves scope, can pause scheduling and can redirect work as requirements change. Artifacts retain their revision history, distinguishing accepted results from earlier submissions.

How I built it

The system combines hierarchical multi-agent orchestration with an event-sourced execution model. StepFun step-5-preview handles structured planning, evaluation and synthesis; saved CREAO agents execute delegated work through app-scoped API Trigger calls. Provider adapters connect these services to a shared TypeScript runtime.

Dependency-aware execution. Plans become typed task graphs with explicit ownership, dependencies and deliverable definitions. Schema and workflow validation checks the graph before execution. The scheduler releases dependent work after prerequisite results have been accepted, then runs eligible independent tasks concurrently. The initial workflow uses a constrained research-first dependency topology.

Contract-driven context propagation. Agents exchange validated artifacts with Zod-defined schemas. Accepted dependency artifacts become downstream inputs, preserving the connection between an upstream finding and the work built from it. Cross-provider output normalization includes a bounded model-assisted repair step when structured results fail validation.

Event-sourced state and artifact lineage. Semantic events are persisted to append-only JSONL logs. A shared pure reducer reconstructs run state, while artifacts retain task ownership, identity and revision metadata. Resumable server-sent events distribute updates. The event stream also supports deterministic state reconstruction for recorded runs without repeating model calls.

Asynchronous execution control. Per-run transaction queues serialize state changes without blocking on remote inference. Job identity and generation checks fence off obsolete callbacks. Abort signals, timeouts, bounded retries and per-key polling coordination constrain failure propagation. When an external run already exists, recovery polling follows that run instead of automatically dispatching another execution.

Node.js and Express host the live orchestration service. Shared TypeScript packages contain contracts and state transitions. React, Zustand, Phaser and Vite support the application, with product design and prototyping developed in Paper. Cloudflare Workers serves the public recorded demonstration and accepted generated site; fresh executions use the configured Node backend. Provider credentials remain server-side.

Challenges I ran into

Reconciling probabilistic computation with deterministic application state. Model responses vary in structure, timing and completeness. The executor still needs precise answers about task ownership, completion and accepted output. I separated provider responses from authoritative state transitions, enforcing validation and review before a result could unlock dependent work.

Maintaining causal consistency across asynchronous boundaries. Human redirection, delayed provider responses and parallel completions can overlap. A late result must not overwrite a newer attempt or propagate superseded context. This required serialized state mutations, attempt-generation fencing and explicit artifact acceptance semantics across the execution lifecycle.

Preserving semantic integrity across model boundaries. Different services expose different response formats and levels of execution detail. A superficially successful response can still contain incomplete deliverables. I built a normalization pipeline with schema-governed artifacts, explicit dependency inputs and bounded repair, giving downstream tasks a reliable data contract.

Recovering under partial observability. An interrupted API response does not necessarily mean the remote agent stopped working. Blind retries can duplicate work and amplify rate limits. The integration distinguishes dispatch from ongoing execution, retains external run identity, coordinates polling and bounds recovery attempts. These controls make uncertainty explicit within the runtime.

Reconstructing execution outside the original session. Reconnection and replay require consistent event ordering and reproducible state projections. Execution events and artifact identities had to remain meaningful independently of the original live session and provider availability.

Accomplishments that I'm proud of

  • Integrated two AI platforms into a working pipeline with real delegated execution, parallel work, accepted deliverables and revision cycles.
  • Established typed boundaries between planning, execution, evaluation and artifact publication.
  • Built context handoffs around accepted outputs, with traceable revisions and reproducible run state.
  • Added human approval and redirection to the execution lifecycle.
  • Published a complete recording of real provider execution alongside its generated output.
  • Verified the implementation with 223 passing tests covering contracts, execution behavior, state reconstruction and deployment routing.

What I learned

Multi-agent quality depends on the infrastructure surrounding inference: task decomposition, context selection, acceptance criteria, failure semantics and ownership of state. A capable model becomes more useful when the system defines what it receives, what it must return and when another task can trust that result.

Separating orchestration policy from provider integration also creates a foundation for extension. New capabilities can be developed against explicit contracts while the execution engine retains responsibility for dependencies, review and lifecycle control.

What's next for Headcount: 1

The next step is a capability registry for configurable agent teams and reusable workflow templates. Operators could add agents around their objectives, supported by new contracts and dependency rules beyond the initial three-worker workflow.

Scaling live execution requires moving beyond the current single-process service. The planned architecture adds queue-backed worker pools, shared event and artifact storage, run-based partitioning and idempotent event consumers. Tenant-scoped credentials, concurrency policies and evaluation datasets would support many independent workflows and measure whether larger agent teams improve results.

Further extensions include persistent business integrations, recurring workflows and policy-based approval gates for consequential external actions.

Built with

TypeScript, Node.js, Express, StepFun Step 5 Preview, CREAO, Zod, React, Zustand, Phaser, Vite, Cloudflare Workers, Paper, Vitest and QRCode. Visual assets include original Paper exports, Kenney CC0 assets, Pixelify Sans and IBM Plex.

How it fits the selected challenges

Applied Intelligence: Practical AI execution for research-led business workflows, producing connected deliverables under human oversight.

CREAO Best One-Person Company: Saved CREAO agents perform core work through API Trigger, with validated artifact handoffs and coordinated execution.

StepFun Get It Done with Step 5 Preview: The live workflow calls step-5-preview for planning, evaluation and synthesis within a functioning multi-provider execution pipeline.

Paper Best Designed Hack: Original product design and prototyping developed in Paper, with source files included below.

Project links

Built With

Share this project:

Updates

Submission history