Orkio

Is your code Orkio?Connecting agents from different devices to work together.Replace github, 0 conflicts, more efficient, keep human in the right loop.

Comment

Orkio — Making Multi-Agent Coding Work Together

Inspiration

AI coding agents have made writing software faster than ever. But when multiple developers use their own AI agents to build the same project, a familiar problem remains: integration.

Each agent works on a separate computer, with limited visibility into what other agents are doing. Even when tasks are carefully divided, agents still share dependencies, interfaces, and assumptions.

For example, one agent might change an API to return timestamps in milliseconds while another continues writing code that expects seconds. Their Git branches can merge perfectly, yet the application breaks.

Git knows whether code can merge. It doesn't necessarily know whether that code works together.

As more agents work in parallel, developers become responsible for communicating changes, resolving conflicts, and keeping everyone aligned. Faster code generation doesn't necessarily translate into faster development when humans still have to coordinate everything.

That's why we built Orkio, a real-time coordination layer that helps AI coding agents on different computers work together with less human intervention.

What it does

Orkio connects AI coding agents across different laptops through a shared coordination system. It gives agents visibility into their teammates' work, detects integration problems, and coordinates their resolution.

The system has four main capabilities:

1. Shared Context Across Computers

Orkio gives agents access to a common source of information about what their teammates are doing.

Through MCP, agents can publish their intentions, including planned changes to files, interfaces, and dependencies. Other agents can access this context while they're still coding, reducing the risk of making incompatible assumptions.

2. Continuous Integration and Conflict Resolution

Orkio captures snapshots of agents' unfinished code through Git.

Factory Droid, our orchestrator, combines changes from different agents and runs integration checks to identify incompatibilities before they reach the main branch.

When a conflict is detected, the system identifies the affected agents and provides the relevant context for resolution. Rather than relying on another agent to rewrite their code, the affected agents can communicate directly and coordinate a fix.

3. Intelligent Task Orchestration

Factory Droid manages task delegation, tracks dependencies, and coordinates agents' work.

When integration issues arise, the orchestrator determines which agents need to be involved and routes the relevant information to them.

This allows agents to continue independent work without requiring developers to manually relay every update between computers.

4. Human in the Right Loop

Orkio aims to automate routine coordination while preserving human control over important decisions.

Ambiguous or high-risk changes can be escalated to developers, and final publication to main remains a human-controlled step.

The goal isn't to remove humans from software development. It's to remove the repetitive coordination work that prevents developers from benefiting fully from parallel AI coding.

How we built it

We built Orkio using Factory Droid SDK, SpacetimeDB, Claude Code hooks, MCP, Git, TypeScript, and Vitest.

The architecture connects agents running in their existing local development environments to a shared, real-time coordination layer.

Hooks and MCP — Connecting Agents Across Laptops

Each developer runs a coding agent on their own computer.

Hooks capture changes to the agent's working tree and create temporary Git snapshots on dedicated wip/<agent> branches.

This lets Orkio access unfinished code without requiring developers to manually commit their work.

Through MCP, agents publish their intentions and retrieve updates from teammates. They can share relevant context without switching to a separate chat application or development environment.

Factory Droid — Our Orchestrator

We use Factory Droid as the central orchestrator for multi-agent collaboration.

Factory coordinates task assignments, tracks development progress, combines agents' code for integration testing, and identifies conflicts between independently developed components.

When it encounters an integration failure, it uses the available code changes, test results, and agent context to determine which agents should participate in resolving the issue.

The affected agents can communicate directly rather than relying on a separate conflict-resolution agent.

One of our biggest technical challenges was determining what information the orchestrator actually needs to make effective decisions. Providing more context isn't always better; we need to identify which task dependencies, intentions, and implementation details are relevant to each decision.

SpacetimeDB — The Shared Context

SpacetimeDB is the real-time coordination backbone of Orkio.

It maintains shared information about:

  • Agent activity and status
  • Code snapshots and development intentions
  • Task assignments and dependencies
  • Integration results and detected conflicts
  • Repair responsibilities and notifications

SpacetimeDB's subscriptions synchronize updates across connected agents and our dashboard.

We also use transactional reducers to keep related coordination operations consistent, such as recording a conflict and assigning its resolution.

Rather than treating SpacetimeDB as a passive message store, we use it as a shared source of coordination state for independently running AI agents.

Git — Integrating Unfinished Code

Git provides a reproducible record of what each agent is working on.

Orkio creates temporary snapshots of unfinished changes and uses them to reconstruct the combined state of the project for testing.

These checks occur outside developers' active branches, so incompatible changes can be identified without disrupting their normal workflows.

Importantly, Orkio doesn't automatically publish changes to main. Developers retain control over final integration.

Dashboard — Visualizing Agent Collaboration

We built a dashboard to make the distributed coordination process visible.

It shows agent activity, shared context, task progress, integration results, and communication between agents.

Since most of Orkio's functionality happens through background processes and tool calls, designing an understandable visualization was an important part of the project.

Challenges we ran into

Rethinking Our Architecture

Our original proposal involved centrally hosted agents, strict file ownership, and a controlled Git publishing system.

While this architecture provided stronger enforcement, it required much more infrastructure and would have forced developers to change their existing workflows.

After evaluating the tradeoffs, we moved toward local coding agents connected through hooks, MCP, Git, and SpacetimeDB.

We also originally considered introducing a separate agent to resolve conflicts. After discussions with mentors, we realized that this introduced unnecessary complexity.

The agents responsible for the conflicting components already have the most relevant context. Instead, we decided to let these agents communicate directly, with Factory Droid coordinating the process.

Effective Task Delegation

One of our hardest challenges was making the orchestrator delegate work effectively.

Factory needs sufficient information about agent responsibilities, dependencies, implementation progress, and conflicts to make useful decisions.

However, providing excessive or irrelevant context can make orchestration less reliable.

We're still refining how to structure and filter that information so the orchestrator can coordinate agents more effectively.

Supporting Different Coding Environments

Orkio works in our tested setup, but not everyone who downloaded it could run it successfully.

Different coding agents and environments use different MCP and hook protocols, creating compatibility challenges.

Making Orkio reliably installable across multiple development environments is an important engineering problem we want to address.

Making Agent Communication Visible

Another challenge was designing the frontend.

Our backend coordinates multiple agents, Git operations, tasks, and real-time state changes. Representing these processes in a way developers can quickly understand was difficult.

We wanted the UI to explain not just what each agent was doing, but how agents were communicating and resolving dependencies.

Accomplishments that we're proud of

We're most proud of building a new, lightweight coordination layer that connects AI coding agents across different computers in real time.

Instead of replacing existing AI coding tools, Orkio makes them work together.

We integrated Factory Droid and SpacetimeDB into a system that coordinates development across independent agent environments, while allowing developers to continue using their normal Git workflows.

We're also proud that we built a working prototype and tested its value through a real development task.

Putting Orkio to the Test

We compared two development setups on the same task: building a Flappy Bird game.

One setup used Orkio, while the other used ordinary GitHub collaboration across two computers.

Metric Orkio GitHub only
Prompts required 2 9
Conflicts recorded 0 1
Total completion time 10 minutes 16 minutes
Tokens used 380K (including 26K for planning) 430K

In this benchmark, Orkio required 78% fewer prompts, finished 37.5% faster, and used approximately 11.6% fewer tokens.

While this was one comparison rather than a statistically validated performance study, the results supported our initial hypothesis: better coordination can reduce the human effort required to turn independently generated code into a working application.

The most encouraging result was the reduction in human prompting. It suggests that agents can handle more of the coordination themselves instead of relying on developers to constantly relay information.

What we learned

The biggest lesson was that making individual AI agents faster doesn't automatically make a team of agents more productive.

Parallel execution creates opportunities for faster development, but it also introduces coordination overhead.

Even when tasks are divided carefully, components share interfaces and assumptions that can change during implementation.

We also learned that more agents aren't always the solution. Our initial conflict-resolution architecture introduced another agent to coordinate changes, but we eventually realized that direct communication between the affected agents could be simpler and more effective.

Another important lesson was that shared context needs to be structured. Giving an orchestrator access to everything isn't necessarily useful; the challenge is delivering the right information at the right time.

Finally, we learned how important it is to distinguish between automated coordination and human judgment. Agents should handle routine communication and integration work, but developers still need control over consequential decisions and final code publication.

What's next for Orkio

We want Orkio to become a general-purpose collaboration layer for AI coding agents, independent of the tools or machines developers use.

Our next priorities are:

Broader compatibility: Support more AI coding tools and address differences in MCP and hook protocols.

Better orchestration: Improve how Factory receives task context and delegates work across agents.

Proactive negotiation: Enable agents to agree on shared interfaces and implementation decisions before conflicts arise.

Smarter conflict detection: Improve attribution when several agents make overlapping changes, including semantic conflicts that existing tests may not detect.

Configurable autonomy: Let development teams define which conflicts agents can resolve independently and which require human approval.

Improved visualization: Build a clearer real-time interface for observing agent communication, dependencies, and integration progress.

Our long-term vision is simple: developers should be able to run multiple AI coding agents across different computers without becoming the communication bridge between them.

Built With

Share this project:

Updates

Submission history