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 method for designing and deploying scalable, multi-agent systems on Kubernetes using ACP (Agent Client Protocol) standardised harnesses, automated PR/task workflows, and ephemeral agent pods. Use it when you need to orchestrate multiple AI coding agents (Codex, Claude Code, OpenClaw) across high-volume inbound work — PRs, bug reports, issues — that is repetitive enough to automate but nuanced enough to require agent judgment. It also applies when building enterprise Slack/Teams/Discord-based agent concierge systems that dispatch disposable agents on demand.
// When should you use the Solmaz On-Demand 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 inputs do you need to deploy disposable agent orchestration?
- 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 are the core principles behind 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 apply the Solmaz agent orchestration framework 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 are real-world examples of disposable agent orchestration in action?
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 disposable agents?
- 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 are the key terms and concepts in disposable 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 On-Demand Disposable Agent Orchestration Framework?
It is a framework for deploying ephemeral AI coding agents on Kubernetes, where each task gets its own full-compute pod that spins up on demand and tears down when done. It uses ACP (Agent Client Protocol) to standardise communication across harnesses like Codex and Claude Code, encodes repeating tasks as Standard Operating Procedures (SOPs), and surfaces agents to humans via a concierge pattern on Slack, Teams, or Discord.
What is ACP and how is it different from MCP and A2A?
ACP (Agent Client Protocol) standardises the interface between a human and an agent. MCP gives tools to a model, and A2A handles agent-to-agent communication. ACP is specifically for the human-talking-to-agent layer, though agents can also use it to call other agents. Its key value is write-once, deploy-everywhere — one adapter works across all compliant harnesses like Codex, Claude Code, or OpenClaw.
How do I set up disposable agent pods on Kubernetes?
Each task gets one Kubernetes pod with a full compute environment. Use a Goal Operator (like the Spritz pattern) to handle provisioning, lifecycle, and teardown automatically. Deploy with helm charts for repeatability. Accept the resource cost as the price of giving each agent a full computer — it is dramatically more powerful than constrained sandboxes. Wire pods to your communication platform via the concierge pattern.
How do I build an agent SOP workflow with ACPX?
Encode your repeating task as an explicit sequence of steps — e.g. find intent, judge quality, check conflicts, verify CI, shallow refactor loop, escalate if needed. Implement each step as a programmatic node in ACPX, which functions as an Argo-like workflow engine driving a harness session. Each node emits structured JSON that feeds the next. Break out of loops and escalate to humans for anything architectural.
How does the Solmaz framework compare to just using a single AI coding agent?
A single agent creates a bottleneck — it cannot handle concurrent tasks or 100+ users. The Solmaz framework dispatches on-demand disposable agents per task, runs parallel channel workloads, and uses a concierge agent as the persistent front door. It also standardises communication via ACP so you can swap harnesses without rewriting integrations, and it encodes workflows as SOPs rather than relying on ad-hoc prompting.
When should I use the Solmaz agent orchestration framework?
Use it when you face high-volume inbound work that is repetitive enough to automate but nuanced enough to require agent judgment — like hundreds of daily PRs, bug reports, or issues. Also use it when you need multiple AI coding agents running in parallel, when you want to swap between harnesses without rebuilding integrations, or when architecting enterprise chat-based agent concierge systems on Slack, Teams, or Discord.
What results can I expect from deploying disposable agent orchestration?
You can expect dramatically reduced mechanical review load — maintainers see only pre-processed, CI-passing, conflict-free PRs. Elapsed time compresses because tasks run in parallel across multiple agent channels. Human involvement shifts from repetitive mechanical work to design judgment calls only. At scale, a 100-person company can handle concurrent debug tasks without bottlenecking on a single shared agent instance.
What is a concierge agent in this framework?
A concierge agent is a persistent front-door agent on Slack, Teams, or Discord that receives human requests and dispatches on-demand disposable agent pods for specific tasks. It returns a UI link to the agent's session when the platform doesn't support multi-agent provisioning natively. The concierge remains available for the next request while each dispatched agent handles its task independently.
What is the telephone game anti-pattern in agent orchestration?
The telephone game anti-pattern occurs when you route instructions through a middle model — e.g. asking Claude to tell Codex what to do. Each intermediary paraphrases, and wording matters critically when prompting agents. This introduces errors and degrades output quality. Use ACP to route instructions directly to the target harness instead of chaining models that reinterpret each other's instructions.
Can I use this framework for non-coding tasks like content review or support tickets?
Yes. The core pattern — SOP workflows, on-demand disposable agents, concierge dispatch, parallel channels — applies to any high-volume task that is repetitive but requires judgment. Content review, support ticket triage, compliance checks, and document processing all fit. Replace coding harnesses with appropriate agent tooling, keep the ACP layer for standardisation, and encode your domain-specific SOPs as structured workflows.
What is ACPX and why do I need it?
ACPX is a CLI tool built on ACP that functions as a Swiss Army knife for agent operations. It lets any agent call any other agent over the command line, binds communication platform channels to harnesses, and houses Argo-like workflow engines that drive harness sessions programmatically. You need it because it is your control plane — replacing manual GUI configuration, app manifests, and ad-hoc scripting with a single standardised tool.