What You'll Learn
Building a Production-Ready AI Agent System in 9 Months
When Benoit Devilliers started AI coding in July 2024, he couldn't have predicted he'd build a sophisticated agent orchestration system by April 2025. His custom dashboard, Visionary, sits on top of OpenClaw and solves real problems that emerge when you move beyond toy projects into actual client work with AI agents.
The Problem with Telegram and Slack for Agent Management
Most OpenClaw users start by managing their agents through Telegram or Slack. It works fine for experimentation, but Benoit quickly hit limitations. When you're running multiple agents across different client projects, a linear chat interface becomes overwhelming. You lose visibility into what each agent is doing, which projects have active pull requests, and whether deployments succeeded.
The breaking point came when Benoit's gateway crashed on a Saturday evening, wiping his agent's memory after a full day of work. He managed to recover by exporting the Telegram conversation history as JSON and rebuilding the agent's context, but it highlighted a critical weakness: relying on chat platforms for production agent orchestration is fragile.
Orchestrator Architecture: One Agent to Rule Them All
Inspired by Elvis Son's architecture on Twitter, Benoit implemented a central orchestrator pattern. Instead of managing multiple specialized agents directly, you interact with a single orchestrator agent. This main agent spawns sub-agents for specific tasks—one for coding, another for content, each with specialized context.
The orchestrator receives requests, determines which sub-agent to spawn, provides the necessary context, and monitors progress. When a coding task arrives, the orchestrator spawns a coding sub-agent with access to the relevant GitHub repository, project documentation, and task specifications. Once complete, the sub-agent reports back and the orchestrator handles the next step—whether that's creating a pull request, notifying the user, or spawning another agent.
This architecture prevents context pollution. Each sub-agent stays focused on its domain without inheriting irrelevant conversation history from unrelated tasks.
Securing Agent Access with GitHub Accounts and Composio
Security was a major design consideration. Benoit created a dedicated GitHub account for his agent with its own email address. For each project, the agent is added as a collaborator with limited permissions. The agent can create branches and open pull requests, but nothing merges without human approval.
For third-party integrations, Benoit uses Composio to manage API keys. Instead of giving agents direct access to services like Linear or Slack, Composio acts as an intermediary. You grant Composio access to your services, then provide your agent with a Composio API key. If you need to revoke access, you simply remove it in Composio's dashboard—no need to rotate keys across multiple services.
For network security, Benoit runs OpenClaw on a VPS and uses Tailscale to create a private network between his laptop, phone, and server. The dashboard URL isn't publicly accessible—it only works within the Tailscale network. This prevents unauthorized access while allowing seamless work across devices.
The Visionary Dashboard: Kanban Boards Meet Agent Orchestration
Visionary's interface centers on a Kanban board showing agent status across projects. Each card represents an active task, displaying whether an agent is working, waiting for review, or has failed. The sidebar houses a chat interface for communicating with the orchestrator.
When Benoit needs a new feature, he describes it in the chat using natural language. The orchestrator asks clarifying questions—an AI interview mode that shapes the ticket before work begins. Once the ticket is properly defined, he spawns a sub-agent by selecting a model (Claude or Codex) and the relevant project.
The center panel shows real-time terminal output as the agent works. You see the agent's thought process, the commands it runs, and any errors it encounters. For debugging, Benoit can SSH into the VPS and inspect logs directly, but usually the terminal view provides enough context.
Push Notifications and Mobile Workflows
One unexpected feature is push notifications. Using an iOS app called Bro, Benoit receives alerts on his phone when agents complete tasks, encounter errors, or need human input. This transforms agent orchestration from a desktop-bound activity into something you can manage anywhere.
The mobile interface, accessible through Tailscale, provides the same Kanban view and chat functionality. Benoit can shape tickets, spawn agents, and review pull requests from his phone—though he admits code reviews are easier on a proper screen.
Cost Management and Model Selection
Running AI agents continuously could get expensive fast. Benoit manages costs by choosing models strategically. For straightforward coding tasks, he uses Claude. When tasks require more reasoning or have failed previously, he switches to more capable (and expensive) models.
The system tracks token usage per task, making it easy to identify which projects or agent types consume the most resources. Benoit estimates his monthly spend is manageable because sub-agents only run when spawned, rather than maintaining persistent connections.
Live Demo: From Ticket to Merged PR
In the live session, Benoit demonstrates the complete workflow. He describes a feature request in the chat, and the orchestrator asks clarifying questions about implementation details, edge cases, and UI considerations. After shaping the ticket, he spawns a coding sub-agent.
The agent appears in the Kanban board with an "in progress" status. In the terminal view, you see it analyzing the codebase, identifying the relevant files, making changes, and running tests. When complete, it creates a pull request and moves to the "review" column.
Benoit reviews the diff, asks for minor adjustments through the chat, and the agent spawns again to implement changes. After a second review, he approves and merges the PR. The entire process—from initial request to deployed feature—takes under 15 minutes.
Building This Without Years of Experience
Perhaps the most remarkable aspect is Benoit's timeline. Nine months from starting AI coding to building a production agent orchestration system isn't typical, but it demonstrates how accessible these tools have become. The combination of AI assistance, modern frameworks like Convex for the backend, and OpenClaw's extensibility made rapid development possible.
Benoit used his agents to build the system itself—a recursive improvement loop where the tool helps build itself. He'd describe a needed feature, spawn an agent to implement it, review the code, and immediately use the new functionality.
Open Source Plans and What's Next
Benoit plans to open source Visionary once it's stable enough for others to deploy. The main challenge is generalizing the setup beyond his specific VPS configuration and workflow. Questions remain about whether non-technical businesses could adopt this system—the answer likely depends on their tolerance for debugging and infrastructure management.
For now, Visionary represents a practical answer to a real problem: how do you manage AI agents when you move beyond experimentation into actual production work? The orchestrator architecture, custom dashboard, and security-first approach provide a template for others building similar systems.
You can follow Benoit's progress on Twitter at @benoit_builds, where he shares updates and eventually the open source release. For anyone serious about using AI agents for real work, his approach offers valuable lessons in architecture, security, and pragmatic tool selection.
