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 spun up per task and torn down on completion. Use it when you need to orchestrate multiple AI coding agents (Codex, Claude Code, OpenClaw) across high-volume inbound work like PRs, bug reports, and issues — especially when that work is repetitive enough to automate but nuanced enough to require agent judgment. It keeps humans out of the mechanical loop entirely.
// When should I 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 and infrastructure do I 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 I avoid when orchestrating disposable 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 do the key terms in on-demand agent orchestration mean?
- 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, each running in its own pod, orchestrated via ACP (Agent Client Protocol) and ACPX CLI. Instead of a single persistent agent, every task gets its own full compute environment that is created on demand and destroyed on completion. The framework uses encoded Standard Operating Procedures (SOPs) to drive repeatable workflows like PR review, bug triage, and refactoring — removing humans from mechanical loops while preserving human oversight for design decisions.
What is ACP and how is it different from MCP and A2A?
ACP (Agent Client Protocol) standardises the interface between a human (or client agent) and an agent. MCP gives tools to a model, and A2A handles agent-to-agent communication. ACP specifically addresses the human-talking-to-agent problem so that one adapter works across all compliant harnesses like Codex, Claude Code, or OpenClaw. This write-once, deploy-everywhere approach eliminates duplicated integration work across editors and platforms.
How do I set up disposable agents on Kubernetes?
Deploy a Goal Operator on your Kubernetes cluster to handle pod lifecycle management. Each task spins up a dedicated pod with a full compute environment — not a constrained sandbox. Use Helm charts for repeatable deployment. Configure ACPX as your CLI control plane to bind communication platform channels to specific harnesses. Add a state synchronisation layer (rsync-style or Dropbox-algorithm) so parallel agents do not produce conflicting file artefacts. Accept the per-pod resource cost as the price of the better abstraction.
How do I automate PR review with AI agents using this framework?
Encode a Standard Operating Procedure (SOP) workflow in ACPX: the agent ingests each PR, independently determines intent (ignoring AI-generated descriptions), judges implementation quality, checks for conflicts, verifies CI status, runs a shallow review-refactor loop for minor fixes, and escalates to a maintainer only when fundamental design decisions are required. Each step emits structured JSON. Maintainers only see pre-processed, CI-passing, conflict-free PRs — dramatically reducing mechanical review load.
How does the Solmaz framework compare to just using a single Codex or Claude Code instance?
A single agent instance creates a bottleneck — it cannot handle concurrent users or tasks. The Solmaz framework deploys one ephemeral agent per task on its own Kubernetes pod, enabling massive parallelism. It standardises communication through ACP so you can swap harnesses (Codex, Claude Code, OpenClaw) without rewriting integrations. SOPs replace ad-hoc prompting with auditable, repeatable workflows. The concierge pattern on Slack or Discord dispatches agents dynamically rather than forcing everyone through one shared session.
When should I use disposable agent orchestration instead of a traditional CI/CD pipeline?
Use disposable agent orchestration when your inbound work requires judgment, not just execution. Traditional CI/CD handles deterministic build-test-deploy steps. This framework handles tasks that are repetitive but nuanced — like reviewing whether a PR is the best possible fix, triaging ambiguous bug reports, or deciding if a refactor is superficial or architectural. If your fire hose of work requires pattern recognition and contextual decision-making at scale, agents are the right tool.
What is the concierge agent pattern?
The concierge agent is a persistent front-door agent on Slack, Teams, or Discord that receives human requests and dispatches on-demand disposable agents for specific tasks. It returns a UI link to the spawned agent's session and remains available for the next request. This eliminates the single-instance bottleneck where one shared agent cannot serve 100+ concurrent users. The Goal Operator handles pod lifecycle automatically — no manual app manifest management required.
What results can I expect from implementing this framework?
Expect dramatic compression of elapsed time on repetitive engineering tasks. A project receiving 300-500 PRs per day can reduce maintainer mechanical review load by surfacing only pre-processed, CI-passing PRs needing design judgment. Engineers can run 3-5 parallel agent sessions simultaneously from a mobile device. Production bug triage becomes self-service via Slack without bottlenecking. The key metric is how much human time shifts from mechanical execution to design decisions.
What is ACPX and what does it do?
ACPX is a CLI tool built on top of 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 SOP-driven Argo-like workflow engines that drive harness sessions programmatically. Think of it as your control plane — it replaces manual GUI configuration and app manifest management with scriptable, automatable commands.
Can I use this framework with Slack or do I need Discord?
The framework works with Slack, Teams, or Discord — any communication platform that supports bot integrations. The concierge pattern is platform-agnostic because ACP standardises the agent interface. The main constraint is that some platforms do not natively support multi-agent cosmetic provisioning, so the concierge returns a UI link (e.g. a React app hosted in-cluster) for the spawned agent's session. ACPX handles binding channels to harnesses regardless of platform.
What are Standard Operating Procedures for agents?
SOPs for agents are encoded, reusable workflows that define the exact sequence of steps an agent takes for a repeating task class. Instead of ad-hoc prompting, you build structured, JSON-output-driven loops — for example: review intent, judge quality, check conflicts, verify CI, shallow refactor, escalate if needed. Each step emits auditable structured output. SOPs are the automatable equivalent of what a human expert does repeatedly, making agent behavior inspectable and improvable.
Turn Any YouTube Video Into An AI Skill
SkillForge captures a creator's exact methodology from their video and turns it into a reusable AI skill you can invoke in Claude, ChatGPT, or any LLM.
Forge your own skill