How We Orchestrate AI Agents in Production with Paperclip, OpenClaw, and Hermes

From the idea of a “central brain” to a Kubernetes-deployed multi-agent architecture a field report from BeezzonlineLab.

When people talk about AI agents in 2026, the conversation usually revolves around the same topic: which model should you use? GPT-4o, Claude, Llama?

But the real question the one nobody asks in Twitter threads is this: how do you make multiple agents work together in production without everything falling apart?

At BeezzonlineLab, we tackled this problem head-on. Our project, cloudeefy-agents, is not a proof of concept. It’s a production-grade multi-agent system running on Kubernetes (Scaleway), with real users, real costs, and real operational constraints.

Here’s how we built it.

The Vision: One Agent per Domain, One Orchestrator to Rule Them All

The classic mistake is trying to build an omniscient agent — a single bot that does everything, from DevOps to sales.

It doesn’t scale. Prompts become unmanageable, context explodes, and performance degrades.

Our approach is radically different: one instance per agent, one runtime per domain, and a clear chain of command.

Paperclip hosts the leadership duo:

• CEO Agent — Defines the vision, strategic priorities, and LLM budgets. It receives high-level objectives.
• CTO Agent — Acts as the platform engineer of the team. It is the critical link: it breaks down CEO objectives into technical tasks, dispatches them to specialized agents, performs code reviews, and redispatches when needed. It also ensures communication between the CEO and operational agents.

OpenClaw / NemoClaw is our runtime for technical agents. Each technical agent runs in its own NemoClaw instance on Kubernetes: SRE, DevOps Engineer, Backend Developer, Frontend Developer, QA Tester. Each instance has its own pod, its own skills, and isolated credentials via a sidecar.

Hermes is our runtime for business agents. The Growth Hacker and Product Manager each run on their own Hermes instance, with persistent cross-session memory and a self-improvement system.

Eight Agents, Eight Specialties

Leadership (Paperclip)

AgentRoleResponsibilities🎯 CEO AgentVision & StrategyDefines goals, manages budgets, tracks global progress⚡ CTO AgentPlatform EngineerBreaks down tasks, dispatches, code reviews, redispatches, CEO ↔ agents interface

The CTO is the pivot of the organization. Without it, the CEO would give vague objectives that agents wouldn’t know how to execute.

Example translation:

“Deploy billing v2.3”

• PM → Write user stories
• Backend → Implement /invoices endpoint
• DevOps → Update Kubernetes manifests

Technical Agents (OpenClaw / NemoClaw)

AgentRole🔍 SRE AgentMonitoring, incidents, capacity checks, SLO tracking🛠️ DevOps EngineerCI/CD, GitOps, infrastructure, deployments⚙️ Backend DeveloperDjango API, database, tests, code review🎨 Frontend DeveloperReact/TypeScript, UI/UX🧪 QA TesterTest suites, regression testing, GitHub issues

Each agent has:

• its own skills (Markdown + YAML frontmatter)
• its own CronJobs
• its own Slack channel

Business Agents (Hermes)

AgentRole📈 Growth HackerCampaigns, analytics, A/B testing, lead scoring📋 Product ManagerRoadmap, user stories, prioritization, feedback

Hermes’ strength lies in its persistent memory and self-improvement loop.

Each interaction feeds a feedback cycle:

• analyze what worked
• update internal skills
• refine strategy

How Agents Collaborate: The Central Role of the CTO

Let’s take a real example: deploying billing v2.3.

Workflow

1. CEO (Paperclip) sets the objective:

• “Deploy billing v2.3”

2. CTO (Paperclip) breaks it down:

• PM → Write user stories
• Backend → Implement + open PR
• DevOps → Prepare Kubernetes manifests + CI

3. CTO reviews the Backend PR:

• ✅ APPROVE → Pipeline continues
• ❌ REJECT → Redispatch with feedback

4. QA Tester runs automatically after merge:

• Tests pass → Report to CTO
• Tests fail → Create GitHub issue → CTO redispatch

5. SRE monitors post-deployment:

• Healthy → SLO report → CTO → CEO
• Regression → Rollback + postmortem

6. Growth Hacker launches campaign once stability is confirmed

👉 The CTO is the quality gate. Nothing reaches production without its validation.

Pod Architecture: Sidecar-Based Credential Isolation

One of the biggest challenges in production AI agents is API key security. Our solution: an inference sidecar.

Each agent pod contains:

• Init container → loads config, prompts, skills
• Inference gateway sidecar (Node.js proxy):
• listens on 127.0.0.1:8080
• routes model requests (OpenAI, Anthropic, etc.)
• injects API keys
• Agent container (NemoClaw):
• only sees localhost:8080
• no API keys exposed
• Istio Envoy → mTLS + routing

👉 Result: even if an agent is compromised, it has no access to API keys.

Deployment: ArgoCD + NemoClaw on Scaleway

Stack overview:

1. Code in GitHub
2. ArgoCD (App-of-Apps) → sync in ~30 seconds
3. NemoClaw runtime:

• Landlock (filesystem isolation)
• seccomp (syscall filtering)

4. Scaleway Kapsule cluster

5. Secret Manager + ESO → automatic secret sync

Paperclip ↔ GitHub Sync Plugin

A major challenge: synchronizing agent workflows with GitHub.We built a bidirectional sync plugin.

Paperclip → GitHub

• CTO dispatch → creates GitHub issue automatically
• Labels, assignees, milestones mapped

GitHub → Paperclip

• PR merged / issue closed → webhook updates status
• CTO triggers next tasks

👉 Humans and agents collaborate on the same issues and PRs.

The Future: Intelligent Model Routing

Not every request needs GPT-4o or Claude Opus.

We’re building a smart routing system:

• Request analysis (complexity, reasoning type)
• Model selection:
• simple → Llama 3 (self-hosted via UnityLLM)
• complex → Claude Opus (cloud)
• Fallback system
• Cost tracking

👉 Expected result: 40–60% cost reduction

What We Learned (Hard Truths)

• One agent = one instance → isolation is worth it
• Skills = context, not callable functions
• CronJobs must contain explicit commands
• Sidecar must bind to 127.0.0.1, not 0.0.0.0
• CTO code review is a critical checkpoint
• A disciplined Git configuration is key to ensuring AI contributors stay aligned, consistent, and production-ready

🔧 Skills recommandés pour chaque agent

🧠 CEO Agent — Vision & stratégie

Skills utiles pour démarrer :

• Roadmap planning SaaS
• Budget allocation LLM / infra
• KPI & growth tracking
• Market analysis automation
• Competitive intelligence

💡 Focus : prise de décision + synthèse

⚡ CTO Agent — Orchestrateur central

Skills critiques (les plus importants de ton système) :

• Task decomposition (epics → subtasks)
• GitHub issue orchestration
• Code review automation
• Multi-agent dispatch logic
• Cost optimization (LLM routing)

🔥 Skills très populaires à viser :

• “code review assistant”
• “task planner LLM”
• “engineering manager agent”

🛠️ DevOps Engineer — Infra & déploiement

Skills recommandés :

• Kubernetes deployment (kubectl + manifests)
• ArgoCD sync automation
• CI/CD pipeline generation
• Secrets management (Vault / ESO)
• Infra troubleshooting

💡 Skills populaires sur skills.sh :

• “kubernetes deploy app”
• “argocd app sync”
• “debug pod crashloop”

🔍 SRE Agent — Monitoring & fiabilité

Skills clés :

• SLO monitoring & alerting
• Incident detection
• Log analysis (Loki / ELK)
• Capacity planning
• Auto-remediation scripts

🔥 Très demandés :

• “analyze logs for errors”
• “detect anomalies metrics”
• “kubernetes health check”

⚙️ Backend Developer — API & logique métier

Skills recommandés :

• Django API development
• Database schema design
• Unit & integration testing
• PR creation & review
• Refactoring code

💡 Skills populaires :

• “build rest api django”
• “optimize sql query”
• “write unit tests python”

🎨 Frontend Developer — UI & expérience

Skills utiles :

• React component generation
• UI/UX improvement suggestions
• API integration
• Performance optimization
• Design system consistency

🔥 Skills populaires :

• “create react component”
• “fix css layout”
• “optimize frontend performance”

🧪 QA Tester — Qualité & validation

Skills essentiels :

• Test case generation
• Regression testing automation
• Bug report generation
• GitHub issue creation
• End-to-end testing

💡 Skills populaires :

• “generate test cases”
• “write playwright tests”
• “detect regression bugs”

📈 Growth Hacker — Acquisition & marketing

Skills recommandés :

• Email campaign generation
• A/B testing strategy
• Funnel analysis
• Lead scoring
• Content generation SEO

🔥 Skills populaires :

• “generate marketing email”
• “analyze conversion funnel”
• “create landing page copy”

📋 Product Manager — Produit & roadmap

Skills clés :

• User story writing
• Feature prioritization
• Feedback analysis
• Roadmap planning
• Documentation (Notion / Markdown)

💡 Skills populaires :

• “write user stories”
• “prioritize features roadmap”
• “analyze user feedback”

🧩 Bonus : Skills transverses (à partager entre agents)

Ces skills sont ultra puissants si mutualisés :

• “summarize long context”
• “extract structured data”
• “generate report markdown”
• “decision making assistant”
• “cost vs performance analysis”

What’s Next?

Our long-term vision: a hybrid organization where humans and 8 AI agents collaborate seamlessly.

Paperclip doesn’t replace teams it amplifies them.

Next steps:

• Intelligent model routing (UnityLLM)
• Inter-agent feedback loops
• RAG on SRE reports (PostgreSQL)
• Specialized fine-tuning

AI agent orchestration in production is no longer theoretical.It’s an engineering problem with real solutions. If our experience helps other teams take the leap, this article has done its job.

Stack mentioned:

• Paperclip Open-source orchestration for AI agents
• OpenClaw Autonomous agent runtime
• Hermes Agent Self-improving agent framework
• NemoClaw Secure NVIDIA runtime for production agents
• Scaleway Kapsule Managed Kubernetes
• ArgoCD GitOps for Kubernetes