Most developers start their AI coding journey with a single agent. You open Claude Code, describe what you need, and watch it work. The results are impressive — fast iteration, thoughtful code, fewer context switches. But as projects grow in scope, one agent becomes a bottleneck. Real productivity gains come from parallelism.
Beyond Single Agents
Imagine building a new feature that touches the API layer, the test suite, and the documentation. With a single agent, these tasks run sequentially. The agent writes the endpoints, then the tests, then the docs. Each step waits for the previous one to finish, even when parts of the work could overlap.
Now imagine three agents working concurrently: one writing API endpoints, another generating integration tests, and a third drafting documentation. The total wall-clock time drops significantly. But this introduces a coordination problem — how do you ensure the test agent waits until the API is actually implemented? How do you track which agent modified which files? How do you avoid stepping on each other’s work when three agents are writing to the same repository?
Glueprint solves this with three primitives: tasks, assistant teams, and Task Flow Definitions.
Tasks, Boards, and Task Flow Definitions
The fundamental unit of work in Glueprint is a task — a discrete piece of engineering work with an owner, a status, and a place on a board. Boards organize tasks by context: every project gets a default board, every assistant team gets one, and you can spin up personal boards for individual focus. The same board renders as a list, kanban, swimlane, or queue.
What gives a board its workflow is the Task Flow Definition (TFD) — a state machine that defines which statuses a task can move through, which transitions are allowed, and which roles are authorized to make them. A team has one TFD. Each team member has a role tag derived from it. When a task moves from one state to the next, the backend checks that the actor holds the right role; transitions that aren’t allowed simply aren’t offered.
This is a sharper model than ad-hoc task tracking. Instead of “anyone can drag any card anywhere,” workflows codify who can move what and when. Reviewers can review. Implementers can implement. Leads can override. The TFD is the contract.
Coordinating Multiple Agents
Multi-agent work in Glueprint runs through assistant teams. A team is a set of long-running AI assistants — each with its own persona, constitution, memory, and harness (Claude Code, Codex, Gemini, or any ACP-compatible harness) — working a shared board against a shared TFD. Teams are cross-host: assistants can live on different machines and still coordinate through the encrypted relay.
Coordination happens via the TFD. When a task lands in a “ready for review” state, only the assistants holding the reviewer role can pick it up. When implementation is done and review passes, the next transition fires. The TFD is not a generic sequencer of tasks — it’s a role-gated state machine that captures the shape of your team’s process.
Assistants do not sit idle waiting for work. Each one has its own routines — cron-driven wake triggers that bring it online on a schedule to check its task queue, journal its progress, and act. A junior implementer might wake every fifteen minutes during business hours; a long-running auditor might wake nightly. The wake context is composed at runtime so each assistant gets fresh memory, due instructions, and recent conversation before it picks up where it left off.
Real-Time Monitoring
While the team works, Glueprint streams every agent session in real time. You see stdout output, tool calls, file changes, thinking blocks, and permission requests — all rendered with purpose-built message components rather than raw terminal text. Subscriptions are scoped: only the sessions you are actively viewing get rendered, so the UI stays responsive even with many concurrent agents.
The same streams reach every surface — desktop, browser, and the mobile app — so you can hand off oversight without re-syncing context. Approve a tool call from your phone. Redirect an agent from the portal. Pick up where you left off from the desktop. The sessions keep going.
Practical Example
Let us walk through building a user authentication feature with an assistant team.
The team’s TFD defines four states — backlog, in progress, in review, done — and three roles: implementer, reviewer, and lead. The TFD allows implementers to move tasks from in progress to in review, but only reviewers can move them to done. You drop three tasks on the team’s board:
-
“Implement auth API endpoints” — starts in backlog. The lead moves it to in progress. The implementer assistant wakes on its routine, picks the task up, scaffolds login/register/refresh endpoints, and moves it to in review. You watch the session stream as it works.
-
“Add auth middleware” — a separate task on the same board. While the API task waits in in review, a second implementer wakes and picks up the middleware task in parallel. The TFD lets implementation proceed on multiple tasks at once without sequencing them.
-
“Auth integration tests” — the third task. When it lands in in review, the reviewer assistant wakes, reads the code, and either approves it to done or sends it back to in progress with comments. The TFD enforces that no implementer can self-approve.
Throughout, every session is visible in the sidebar, every task carries assignment, status, and due date, and the board renders as a kanban so you can see the work flow across roles at a glance. Mobile mirrors the same view, so you can check progress from your phone without opening a laptop.
File Change Tracking
As agents work, Glueprint tracks every file modification through its git integration. Each session records the base git commit at the time work started, plus a running summary of files changed, additions, and deletions. You can open the changes panel to see which files each agent touched, view inline diffs, and commit directly from the app.
In multi-agent scenarios where two agents might touch overlapping areas of the codebase, this turns “discover conflicts after the fact” into “see the changes as they happen.” Each session also tracks the git branch it is working on, so you can isolate each agent’s work on a separate branch and merge intentionally.
Cloud Relay for Remote Workflows
Multi-agent workflows can run for a long time. A team’s TFD might cycle a single task through implementation, review, and rework over hours. Glueprint’s optional cloud relay lets you monitor progress from anywhere.
Every event is encrypted client-side with AES-256-GCM before it leaves your machine. The relay server routes encrypted envelopes between clients but never sees plaintext content. Decryption keys are derived client-side from a device-held secret using PBKDF2-SHA256 with 600,000 iterations, so only your clients can read the data. To understand how this works at the protocol level, see our deep dive on zero-knowledge encryption.
If a client disconnects and reconnects, the protocol recovers any missed events automatically — no full resyncs, no data loss. Start a workflow on your desktop, walk away, and check progress from the portal on your phone. The agents keep working, Glueprint keeps streaming, and the cloud relay keeps everything in sync.
Getting Started
Spin up an assistant team, define your TFD, drop tasks on the board, and let the team execute. Start with two assistants and a simple three-state flow; scale up as your workflow stabilizes. The model is designed to grow with you — from a single assistant on a personal board to a full role-gated team with multiple harnesses, parallel work, and real-time monitoring across every device you own.