In Part 2, we discussed migrating CoWorker to a structured ADK setup in Go with a strict ToolsRegistry. But a unified toolset doesn't solve the problem of LLM focus. If an agent has access to all tools—Platform and Workspace—it still tries to reason about everything at once.
The solution is Multi-Agent Orchestration via Agent-to-Agent (A2A) flows. We broke the monolith down into highly specialized roles.
The Agent Roster
Currently, the CoWorker ecosystem consists of three specialized agents working together:
1. The Orchestrator
Tools: None.
Role: The delegator. The Orchestrator is the entry point for user prompts. It has no tools of its own; its sole purpose is to understand the overarching goal, break it down into steps, and delegate those steps to the specialized agents via A2A.
2. The Provisioner
Tools: Platform Tools only.
Role: Infrastructure management. If the Orchestrator determines a new V-Collab workspace needs to be created or checked, it passes the context to the Provisioner, which executes against the V-Collab APIs.
3. The Developer
Tools: Workspace Tools only.
Role: The coder. When the Orchestrator needs files read, dependencies installed, or code written inside the container, it calls the Developer agent. Because the Developer's system prompt is hyper-focused on coding, its reasoning is vastly superior to a generalist agent.
The Roadmap: As the system grows, we are expanding this roster to include a dedicated Tester, Reviewer, and Planner.
Taming Context with RAG (Context Compression)
One of the biggest issues in agentic coding is the size of terminal outputs. If the Developer agent runs npm install, the output can be massive, flooding the context window and blinding the LLM.
To solve this, we currently use a form of Retrieval-Augmented Generation (RAG) for Context Compression. Instead of blindly appending massive execution logs to the prompt history, we summarize and compress them, ensuring the agent retains only the critical signals (e.g., "Dependency installed successfully" or "Error: React version conflict on line 42").
The Future of RAG: Full Codebase Indexing
While compression is our current RAG implementation, the ultimate goal is full codebase awareness. Soon, CoWorker will index every file in a V-Collab workspace.
- The system will read the user's codebase, run it through an
Embed()function, and store the vectors in apg_vectortable. - When a user asks, "How is authentication handled here?", the Orchestrator will convert that query into an embedding, perform a cosine similarity search against the indexed files, and inject the top K results directly into the Developer agent's system prompt as context.
Conclusion
Building CoWorker has been an incredible engineering journey. By leveraging Go's concurrency, the reasoning power of Azure AI Foundry (GPT-5.4 Pro), and a strict Multi-Agent A2A architecture, we've created a system that doesn't just chat about code—it actively builds it.
The days of the monolithic, single-prompt chatbot are over. The future belongs to orchestrated, specialized agents.