Solmaz On-Demand Disposable Agent Orchestration Framework
Design and deploy a scalable, multi-agent system on Kubernetes using ACP-standardised harnesses, automated PR/task workflows, and on-demand disposable agents — so humans stay out of the mechanical loop entirely.
// TL;DR
The Solmaz On-Demand Disposable Agent Orchestration Framework is a system design for running multiple AI coding agents (Codex, Claude Code, OpenClaw) at scale on Kubernetes. Each task spins up its own ephemeral agent pod — a full compute environment — coordinated through ACP (Agent Client Protocol) and the ACPX CLI. Use it when you face a high-volume 'fire hose' of repetitive-but-nuanced inbound work (300+ PRs/day, bug triage, issue backlogs) that's automatable but needs agent judgment. It surfaces agents through a concierge pattern on Slack, Teams, or Discord, encodes repeating tasks as Standard Operating Procedures, and keeps humans out of the mechanical loop entirely.
// When should you use the disposable agent orchestration framework?
Use this skill when you need to orchestrate multiple AI coding agents (Codex, Claude Code, or similar) across tasks at scale — especially when facing high-volume inbound work (PRs, bug reports, issues) that is repetitive enough to automate but nuanced enough to require agent judgment. Also applicable when architecting enterprise Slack/Teams/Discord-based agent concierge systems.
// What do you need before deploying disposable agents on Kubernetes?
- Agent harness(es)required
One or more agent harnesses to orchestrate (e.g. Codex, Claude Code, OpenClaw). These are the underlying AI coding agents that will be driven. - Communication platformrequired
The chat platform where agents are surfaced to humans (Slack, Teams, Discord). Determines integration approach and multi-agent provisioning constraints. - Task volume and typerequired
The category and approximate daily volume of inbound work (e.g. GitHub PRs, bug reports, feature requests). Used to decide workflow depth and agent parallelism. - Infrastructure targetrequired
The Kubernetes cluster (or equivalent) where agent pods will be deployed. Needed to configure the operator and helm charts. - State synchronisation mechanismrequired
The method for keeping file state in sync across agents (e.g. rsync-style, Dropbox-algorithm equivalent, GitHub read/write access). - ACP-compatible server or CLIrequired
An ACP server (e.g. Codex app server protocol, ACPX CLI) to standardise agent-client interaction across harnesses.
// What core principles guide on-demand disposable agent orchestration?
On-Demand Disposable Agents
Every task gets its own ephemeral agent instance — a full Kubernetes pod — spun up on demand and torn down when done. This is wasteful in resource terms but is the better abstraction because giving a full computer to an agent is dramatically more powerful than constrained sandboxes.
Agent Client Protocol (ACP) as the Interoperability Layer
ACP (Agent Client Protocol) standardises the human-to-agent interface so that one plugin or adapter works across all harnesses (Codex, Claude Code, Zed, etc.) instead of each editor building its own. This eliminates duplicated work. ACP is distinct from MCP (which gives tools to the model) and A2A (agent-to-agent); ACP is specifically for human-talking-to-agent, though agents can also use it to talk to other agents.
Automating the Automator
When you notice yourself repeating the same mechanical judgment steps (e.g. reviewing a PR for intent, checking CI, resolving conflicts), that pattern is a signal to encode it as a workflow and hand it to an agent. You are not automating creativity — you are automating the scaffolding around it.
Standard Operating Procedures for Agents
Reusable agent workflows are effectively SOPs (Standard Operating Procedures) for agents. Rather than ad-hoc prompting, you build structured, JSON-output-driven loops (review → judge → refactor → relate-to-human) that can be replayed, inspected, and improved.
Apply Agents Generously
Treat agent capability like an ointment — apply it generously to any problem that can be solved with agents. The default posture should be: how do I take myself out of this loop?
Parallel Channel Workloads
Rather than one agent per session, run one agent per task channel (e.g. Codex-1 through Codex-5 in Discord). Parallel workloads across bounded channels enable coding-on-the-go and compress elapsed time dramatically.
Ship of Theseus Harness Evolution
A harness (agent coding environment) does not need to be rebuilt from scratch as requirements evolve — it can be ripped apart and put back together iteratively. The identity of the system is maintained through continuity of use, not continuity of implementation.
Shallow Bug Loops vs. Design Loops
Running an agent in a review-refactor loop is acceptable and does not necessarily produce slop — provided you are making it uncover shallow bugs, not design something from scratch. Distinguish between superficial refactors (agent-safe) and fundamental refactors (relate back to the human).
// How do you build a scalable multi-agent system step by step?
- 1
Audit your inbound task fire hose
Identify the volume and nature of inbound work (PRs, issues, bug reports). Classify tasks into: (a) fully automatable mechanical work, (b) agent-assisted work requiring human sign-off, and (c) work requiring human design judgment. Only (a) and (b) enter the agent workflow.
- 2
Select and configure your agent harnesses
Choose one or more harnesses (Codex, Claude Code, OpenClaw, etc.). Avoid the telephone game anti-pattern — do not chain agents by having one LLM paraphrase instructions to another if you can route directly. Use ACP adapters to standardise communication so harnesses are interchangeable.
- 3
Stand up ACPX as your Swiss Army knife CLI
ACPX is the CLI layer that lets any agent call any other agent over the command line via ACP. Install it and bind your communication platform channels (Discord, Slack, Teams) to specific harnesses through ACP. This is your control plane — not a GUI, not manual app manifests.
- 4
Design your Standard Operating Procedure (SOP) workflow per task type
For each repeating task class (e.g. PR intake), encode the workflow as an explicit sequence: (1) Find intent, (2) Judge implementation quality, (3) Check for conflicts, (4) Verify CI status, (5) Shallow refactor loop if needed, (6) Relate to human only if fundamental refactor required. Output each decision as structured JSON so it is auditable and pluggable into a workflow engine.
- 5
Implement the SOP in ACPX as an Argo-like workflow engine driving a harness session
ACPX functions as an Argo-like workflow engine but drives a Codex (or equivalent) session rather than raw containers. Wire your SOP steps as programmatic nodes. Each node emits structured JSON that feeds the next node. Review-refactor loops are acceptable for shallow bugs; break out of the loop and escalate to human for anything architectural.
- 6
Deploy on-demand disposable agent pods on Kubernetes
Each task gets one Kubernetes pod — a full compute environment, not a constrained sandbox. Use a goal operator (e.g. the Spritz pattern at textcortex/spritz) to handle provisioning, lifecycle, and teardown. Use helm charts for repeatable deployment. Accept the resource cost as the price of the better abstraction.
- 7
Configure state synchronisation across agent pods
Agents editing files concurrently require a synchronisation layer. Grant read/write GitHub access and layer an rsync-style or Dropbox-algorithm synchronisation mechanism so file state is consistent. Without this, parallel agents produce conflicting artefacts.
- 8
Surface agents via the concierge pattern on your communication platform
Create a single concierge agent on Slack/Teams/Discord that humans talk to. The concierge dispatches on-demand disposable agents for specific tasks and returns a UI link (e.g. React app hosted in-cluster) when the platform does not support multi-agent cosmetic provisioning natively. Do not try to manage agent app manifests by hand — automate provisioning through the operator.
- 9
Run parallel channel workloads and iterate
Operate one agent per task channel (e.g. channels named by harness + task index). Monitor across 1–5 channels simultaneously. Treat your own tool limitations as first-class signals — if you are playing the telephone game or clicking manually, that is the next thing to automate.
// What does disposable agent orchestration look like in practice?
An open-source project receives 300–500 pull requests per day, many AI-generated with poor descriptions and failing CI.
Deploy the SOP workflow: (1) ACPX ingests each PR, (2) the agent determines intent (asking what the PR actually does), (3) judges whether it is the best possible fix, (4) checks for conflicts, (5) runs a shallow review-refactor loop to fix CI failures, (6) escalates to a maintainer only when a fundamental design decision is required. The maintainer sees only pre-processed, CI-passing, conflict-free PRs, dramatically reducing mechanical review load.
A 100-person company wants agents on Slack to handle production error triage without bottlenecking on a single shared agent.
Deploy a concierge agent on Slack. When an engineer asks about new bugs after a prod release, the concierge dispatches an on-demand disposable agent pod on Kubernetes for that specific debug task, provides a UI link to that agent's session, and the engineer continues there. The concierge remains available for the next request. The operator handles pod lifecycle. No manual Slack app manifests; no single-instance bottleneck.
A developer wants to work on multiple side projects simultaneously while commuting, without access to a full desktop IDE.
Bind a Discord channel to a harness session via ACPX. Run parallel channel workloads (e.g. Project-A, Project-B, Project-C channels). Use another channel to retrieve artefacts the agent cannot send directly (e.g. generated PDFs placed in /tmp). Each channel is effectively a full IDE session driven by an on-demand agent.
// What mistakes should you avoid when orchestrating agents at scale?
- The Telephone Game anti-pattern: routing instructions through a middle-model (e.g. asking Claude to tell Codex what to do) introduces paraphrasing errors. Wording matters when prompting — use ACP to route directly.
- Managing agent app manifests manually: clicking through Slack/Teams/Discord app creation UIs for each agent is unscalable. Automate provisioning through an operator from day one.
- Using agents for design decisions in refactor loops: looping an agent on refactors is safe for shallow/superficial bugs. Using it to design architecture produces slop. Always distinguish — fundamental refactors must be related back to a human.
- Treating AI-generated PR descriptions as ground truth: most inbound PRs have AI-generated, low-signal descriptions. Always have the agent determine intent independently before judging implementation.
- Single-instance agent bottleneck: one agent instance per platform integration cannot handle 100+ concurrent users. The concierge pattern with on-demand disposable agents is the correct architecture.
- Ignoring low-quality PRs entirely: even slop PRs are crucial user feedback data points indicating where something in the codebase is broken. Categorise and bin them — do not discard them.
- Skipping state synchronisation: running parallel agent pods without a file-state sync layer causes agents to produce conflicting artefacts silently.
// What key terms should you know for ACP and agent orchestration?
- ACP (Agent Client Protocol)
- A protocol standardising the interface between a human (or agent acting as client) and an agent. Distinct from MCP (tool-giving) and A2A (agent-to-agent). Its key value is write-once, deploy-everywhere — one adapter works across all compliant harnesses.
- ACPX
- A CLI tool built on top of ACP that functions as a Swiss Army knife for ACP operations. Enables any agent to call any other agent over the command line and houses SOP-driven Argo-like workflow engines that drive harness sessions.
- Harness
- The full coding agent environment wrapping an AI model — including context, tooling, and integration layer (e.g. Codex, Claude Code, OpenClaw). A harness is distinct from the model itself.
- On-Demand Disposable Agents
- Ephemeral agent instances, each running in its own Kubernetes pod, created for a specific task and torn down on completion. Emphasises full compute environment per agent over constrained sandboxes.
- Concierge Agent
- A persistent front-door agent on a communication platform (Slack, Teams, Discord) that receives human requests and dispatches on-demand disposable agents for specific tasks, returning UI links when needed.
- Standard Operating Procedures for Agents (SOPs)
- Encoded, reusable agent workflows that define the exact sequence of steps an agent takes for a repeating task class. The structured, automatable equivalent of what a human expert does repeatedly.
- Argo-like Workflow Engine
- A workflow execution model (referencing Argo Workflows on Kubernetes) where tasks are DAG-structured nodes with JSON-structured outputs. ACPX uses this pattern to drive harness sessions programmatically.
- Parallel Channel Workloads
- Operating multiple simultaneous agent task sessions, each bound to a dedicated communication platform channel (e.g. Codex-1 through Codex-5 in Discord). Enables concurrent task execution from a single human operator.
- Telegram Driven Development (TDD)
- A development workflow pattern where agent tasks are dispatched, monitored, and iterated via messaging platform channels (Telegram, Discord, Slack) rather than traditional IDEs.
- Shallow Bug Loop vs. Fundamental Refactor
- The key distinction in agentic refactor workflows: shallow bugs (easily uncovered and fixed in a loop without human input) vs. fundamental refactors (require human design judgment and must be escalated out of the loop).
- Fire Hose
- A high-volume, continuous stream of inbound work items (PRs, issues, bug reports) that exceeds human capacity to process manually — the core problem that agent orchestration is designed to absorb.
- Goal Operator
- A Kubernetes operator that handles the full lifecycle of on-demand disposable agent pods — provisioning, wiring to communication platforms, state management, and teardown — abstracting infrastructure complexity from the agent user.
// FREQUENTLY ASKED QUESTIONS
What is the Solmaz disposable agent orchestration framework?
It's a system for running many AI coding agents at scale on Kubernetes, where every task gets its own ephemeral agent pod that's spun up on demand and torn down when done. Agents are standardized through ACP (Agent Client Protocol) and driven by the ACPX CLI, letting you automate high-volume work like PR review and bug triage while keeping humans out of the mechanical loop.
What is ACP and how is it different from MCP?
ACP (Agent Client Protocol) standardizes the interface between a human — or an agent acting as a client — and an agent, so one adapter works across all harnesses like Codex, Claude Code, and Zed. It's distinct from MCP, which gives tools to the model, and A2A, which is agent-to-agent. ACP is specifically for human-talking-to-agent, though agents can also use it to talk to other agents.
How do I orchestrate multiple AI coding agents at scale?
Audit your inbound task volume, select agent harnesses, and stand up ACPX as your control-plane CLI to bind chat channels to harnesses via ACP. Encode each repeating task type as a Standard Operating Procedure (SOP) workflow, deploy one disposable Kubernetes pod per task, add a state synchronization layer, and surface everything through a concierge agent on Slack, Teams, or Discord.
How do I automate PR review with AI agents?
Encode PR intake as an SOP: ingest the PR, have the agent independently determine intent, judge implementation quality, check for conflicts, verify CI status, run a shallow refactor loop to fix failures, and escalate to a human only when a fundamental design decision is required. Output each step as structured JSON so it's auditable, and the maintainer sees only pre-processed, CI-passing, conflict-free PRs.
How does this framework compare to using a single shared agent?
A single shared agent instance per platform integration becomes a bottleneck — it can't handle 100+ concurrent users. This framework uses on-demand disposable agents where each task gets a full Kubernetes pod, dispatched by a persistent concierge agent. This eliminates the single-instance bottleneck and gives each agent a full compute environment rather than a constrained sandbox, which is a dramatically more powerful abstraction.
When should I use disposable agent orchestration?
Use it when you face a high-volume 'fire hose' of inbound work — PRs, bug reports, issues — that is repetitive enough to automate but nuanced enough to require agent judgment. It's also ideal when architecting enterprise Slack, Teams, or Discord agent concierge systems, or when you catch yourself repeating the same mechanical judgment steps that could be encoded as a workflow.
What results can I expect from this framework?
You dramatically compress elapsed time and remove humans from mechanical loops. An open-source project drowning in 300–500 PRs/day can have maintainers see only pre-filtered, CI-passing PRs. A 100-person company can triage production errors without bottlenecking on one shared agent. Individual developers can run parallel work across multiple side projects from a phone via bound chat channels.
What is the concierge agent pattern?
The concierge is a persistent front-door agent on Slack, Teams, or Discord that humans talk to. It receives requests and dispatches on-demand disposable agent pods for specific tasks, returning a UI link (like an in-cluster React app) when the platform doesn't natively support multi-agent provisioning. The concierge stays available for the next request while the operator handles pod lifecycle, avoiding manual app manifests.
What is ACPX and why do I need it?
ACPX is a CLI tool built on top of ACP that acts as a Swiss Army knife for ACP operations. It lets any agent call any other agent over the command line and houses Argo-like workflow engines that drive harness sessions via your encoded SOPs. It's your control plane — not a GUI, not manual app manifests — binding chat channels to harnesses and executing structured JSON workflows.
How do I stop parallel agents from producing conflicting files?
Add a state synchronization layer across agent pods. Grant read/write GitHub access and layer an rsync-style or Dropbox-algorithm mechanism so file state stays consistent across concurrently editing agents. Without this synchronization, parallel agents silently produce conflicting artefacts, which is one of the most common pitfalls when scaling disposable agents on Kubernetes.
Should I use agents for refactoring code?
Only for shallow bugs, not architectural design. Running an agent in a review-refactor loop is safe and doesn't produce slop when you're making it uncover superficial bugs. But using it to design something from scratch or make fundamental refactors produces low-quality output. Always distinguish: shallow refactors are agent-safe; fundamental refactors must be escalated back to a human.