How Convivy builds and runs several products with two people — by treating a roster of Claude agents as a trained crew.
At Convivy, the team is two people. We build and maintain multiple production products because we've built an agentic development platform on top of that small team, a system where Claude agents draft code, review it for correctness and security, and queue it for human approval, continuously, overnight and during the day. The platform multiplies the surface area two people can hold at once.
We call the infrastructure that makes this possible the substrate. It has three layers:
The knowledge layer is the canonical doc store: every runbook, decision record, agent profile, and orientation doc lives in a single git repository. A local search index and an MCP server let agents query that store in real time.
The orchestration layer is the machinery that runs agents: a roster of purpose-built Claude agents (planners, coders, bug-fixers, reviewers, security reviewers, and more), a dispatcher (agentctl) that spawns and tracks them, and a session wrapper (co) that opens an interactive session with the right orchestrator for the task at hand. Each agent has a specific role, a bounded set of tools, and a well-defined handoff protocol.
The daily-operation layer is the repeatable workflow that ties the other two together, covering the daytime and overnight patterns described below.
Rather than one general-purpose AI assistant, we maintain a roster of specialized agents. A planner explores ambiguous requirements and proposes a scope. A coder implements it. A reviewer reads the resulting diff with adversarial intent, tagging findings as blocking or non-blocking. A security reviewer runs in parallel. When the reviewer finds something blocking, the coder revises and the cycle repeats, up to three cycles before a human weighs in.
Each agent is a prompt-engineered role materialized into the product's working directory before a session begins. The roster grows as the platform matures; adding a new agent is lightweight, and idle agents cost nothing.
During the day, Jay opens a co session in a product repo and states a task: a bug fix, a small feature, or a refactor. The planning orchestrator settles scope (asking clarifying questions with recommended answers), then dispatches the right specialist: a coder for settled scope, a planner for ambiguous scope, a bug-investigator before a bug-fixer if the cause is unclear.
Once the worker finishes, the orchestrator dispatches the reviewer and security reviewer. Their findings loop back to the coder for revision, and the reviewers re-pass on the new head. When the cycle is clean, a PR lands ready for human review. Jay reads the diff, merges or redirects.
Throughout the session, Jay is present: watching for drift, approving anything the orchestrator flags as high-risk, and making the final merge call. The agents produce the work; Jay decides what ships.
Every night at 1 a.m., a scheduled job fires and drains the backlog for that night's assigned product. The backlog is a simple markdown queue file, a prioritized list of tasks the team has approved for autonomous execution: mechanical refactors, test-coverage gaps, safe dependency updates, bug-queue drain.
The overnight orchestrator works through the queue top-to-bottom, dispatching workers and running the same review cycle the daytime workflow uses. It produces reviewed, ready-to-merge PRs and stops. Nothing merges autonomously. By morning, Jay has a digest in Slack summarizing every PR that landed, any items that were deferred and why, and what's waiting for his review on GitHub.
Overnight is deliberately narrow: novel features, API contract changes, and anything requiring external credentials stay in the daytime queue where Jay is present.
No agent merges a PR. The platform's branch protection and the team's operating rule agree on this: a human reads the diff and clicks merge. Agents draft, review, revise, and queue; the final gate belongs to Jay. The agents handle breadth; Jay handles judgment.