Fluxion Bus
The Fluxion Bus MCP server enables a primary AI agent to delegate scoped tasks to local AI executors and manage their full lifecycle.
Submit sub-agent tasks: Delegate a prompt to Codex, Claude Code, or Antigravity with configurable read-only or workspace-write modes, model selection, session/thread continuity, async or blocking execution, and project/workspace targeting.
List available models: Query selectable models for a given executor, enriched with pricing context, to make informed per-run model overrides.
Manage projects: List all configured Fluxion projects or retrieve a specific project by key for proper workspace and project targeting.
List recent runs: Browse sub-agent task history, filterable by agent, status, project, or path prefix.
Poll task status: Check the current status of a running or completed task, with long-polling support, progress signals, recent output tail, changed files, and diff summaries.
Cancel a running task: Request cancellation of an active sub-agent run.
Revert workspace changes: Undo recoverable text-file modifications made by a specific run to safely roll back workspace edits.
Retrieve task results: Fetch a structured result for a completed run, optionally including raw output and full execution logs.
Enables remote task submission and control of local executors via LINE messages, with progress updates and result delivery.
Enables remote task submission and control of local executors via Slack messages, with progress updates and result delivery.
Enables remote task submission and control of local executors via Telegram messages, with progress updates and result delivery.
Enables remote task submission and control of local executors via WeChat messages, using iLink QR-code login for account binding.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Fluxion Bus delegate code review to Claude Code"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
https://github.com/user-attachments/assets/10d83427-f363-4306-b1de-fa8ebef662ec
Illustrative demo with staged data, not a live recording.
Fluxion Bus is the open-source project behind the Fluxion macOS app and local agent gateway.
Fluxion lets your primary AI agent delegate scoped tasks across Codex, Claude Code, and Antigravity through one local MCP server.
Stay inside your current agent while Fluxion routes work to another provider, preserves sessions, reports progress and results, and records file changes for review or recovery.
Fluxion also reads provider-reported quota windows, detects and notifies you when the provider resets them, and can automatically make a minimal Agent call after a reset to start the next rolling window immediately.
Quota and usage data are not limited to tasks delegated through Fluxion. Fluxion reads them directly from provider APIs, local agent services, or local agent histories; it does not calculate provider quota from Fluxion task records.
Local-first, single-tenant, and self-hosted. No Fluxion account or SaaS
dependency; default exposure is 127.0.0.1.
Why Fluxion
Cross-provider delegation without leaving your primary agent
┌────────────────────────────────────────────┐
│ Primary agent │
│ Codex / Claude Code / Antigravity │
└─────────────────────┬──────────────────────┘
│ MCP: delegate scoped subtask
▼
┌──────────────────┐
│ Fluxion MCP │
│ route + supervise│
└────────┬─────────┘
│
┌────────────┼────────────┐
▼ ▼ ▼
Codex Claude Code Antigravity
│ │ │
└────────────┼────────────┘
▼
status / result / changed files / revert
│
▼
Primary agentRoute each subtask to a different provider.
Continue executor-native sessions across repeated calls.
Choose read-only investigation or explicitly authorized edits.
Inspect async status, logs, artifacts, and changed files.
Revert recoverable text-file changes after review.
Turn quota resets into usable windows
Claude quota Codex quota Antigravity quota
└───────────────┬──────────────────┘
▼
┌─────────────────┐
│ Fluxion quota │
│ monitor + sched │
└────────┬────────┘
│
┌────────────┼──────────────┐
▼ ▼ ▼
Web UI macOS app Reset detected
│
Auto Ping + notify
Slack/Telegram/WeChat/LINE/QQ/FeishuSee remaining quota and reset countdowns across providers.
Monitor provider/account quota, including usage made outside Fluxion.
Use the browser-based console on macOS or Linux.
Use the native macOS app for menu bar quota, service controls, and setup.
Detect provider-side quota resets.
Automatically make a minimal Agent call after a detected reset to start the next rolling window.
Send quota-reset notifications through Slack, Telegram, WeChat, LINE, QQ, or Feishu.
Control local agents remotely
Send tasks from Slack, Telegram, WeChat, LINE, QQ, or Feishu while away from your computer. Fluxion routes the message to a local Codex, Claude Code, or Antigravity executor, then returns progress updates and the final result in the same conversation.
Phone / remote device
Slack/Telegram/WeChat/LINE/QQ/Feishu
│
▼
Fluxion messaging gateway
│
▼
Codex / Claude / Antigravity
│
▼
progress updates + final resultRemote conversations preserve their executor session, so follow-up messages can continue the same task context. Users can also inspect recent tasks, check gateway status, reset a conversation, or cancel queued/running tasks through channel control commands.
WeChat uses iLink QR-code login. Bind the account once, enable the channel, and start the same messaging gateway used by the other messaging channels.
Related MCP server: Agent Switchboard
Platform Support
Capability | macOS | Linux | Windows |
MCP cross-provider delegation | Supported | Expected, not verified | Not verified |
Web quota console | Supported | Expected, not verified | Not verified |
Scheduler auto-ping and notifications | Supported | Expected, not verified | Not verified |
Native macOS app | macOS 12+ | Not available | Not available |
Linux support is expected for non-native features based on the implementation, but has not yet been manually verified.
The menu bar app runs on macOS 12 or newer; its Launch at Login toggle requires macOS 13+ and is disabled on macOS 12.
Provider quota probes depend on compatible local credentials or services. Antigravity live quota, for example, requires its local sidecar to be running. The displayed quota comes from those provider or agent sources, not from a counter of tasks routed through Fluxion.
Install and Verify
Requirements:
At least one installed and authenticated executor CLI:
codex,claude, oragyCodex: either the standalone CLI, or the Codex desktop app — its bundled CLI is detected automatically on macOS, and its login satisfies auth.
Python 3.12+ (Python 3.13 recommended) for CLI/backend installs. The macOS desktop app can install
python@3.13through Homebrew when needed.Node 18+ only when rebuilding the Web console frontend locally.
macOS desktop app (recommended)
The desktop app runs on Apple Silicon (M-series) Macs. Intel users should build from source or use the CLI installation below.
The easiest way in is Homebrew:
brew install --cask superposed-labs/tap/fluxionThe cask clears the quarantine flag for you, so there are no Gatekeeper
steps — just launch it. Update later with brew upgrade --cask fluxion.
No Homebrew? Download the Fluxion.app DMG from the latest Release (verify it against SHA256SUMS) and drag it into /Applications. The app is unsigned and not notarized, so Gatekeeper blocks the first launch: either open System Settings → Privacy & Security and click Open Anyway, or run the command below to clear quarantine yourself:
xattr -dr com.apple.quarantine /Applications/Fluxion.appOn first launch, Fluxion uses ~/.local/share/fluxion as the managed backend path and offers Install / Repair. The app then installs the backend from the source snapshot and dependency wheels bundled inside the app, creates .venv, initializes .env, and starts the local services — no git, network access, Xcode Command Line Tools, or local Node build required.
If Python 3.12+ is not already available and Homebrew is installed, the
installer uses Homebrew to install python@3.13; without Homebrew, the app
points you to the python.org installer before setup starts. Executor CLIs such
as codex, claude, or agy still need to be installed and authenticated
separately.
Let your agent configure CLI/MCP
For CLI-first use, MCP registration, or non-desktop installs, the agent you already use can run the backend installation end to end: prerequisites, installer, MCP registration for your client, and verification. Paste this into Claude Code, Codex, or Antigravity from the project directory you want Fluxion to work on:
Read https://raw.githubusercontent.com/superposed-labs/fluxion-bus/main/docs/agent-install.md
and follow it to install and configure Fluxion on this machine. Use the current
directory as the first authorized workspace, register the MCP server with the
client you are running in, then run the verification steps and report the results.The agent follows docs/agent-install.md, which wraps the same installer used below. It finishes with a per-component status report covering the backend CLI, MCP registration, and Web console static assets. The macOS desktop app is distributed separately through the Release DMG.
Manual install
Install or update Fluxion for the current user:
curl -fsSL https://raw.githubusercontent.com/superposed-labs/fluxion-bus/main/scripts/install.sh \
| bash -s -- --no-desktopThe installer uses ~/.local/share/fluxion, links commands into
~/.local/bin, and installs the CLI, Gateway, and MCP commands. The prebuilt
macOS app is distributed through the Release DMG; use the source installer for
backend/CLI setup and development workflows. Run the same command again to
update while preserving .env and data/.
By default, the directory where the install command is run becomes the first authorized workspace. Override it when needed:
curl -fsSL https://raw.githubusercontent.com/superposed-labs/fluxion-bus/main/scripts/install.sh \
| FLUXION_WORKSPACE=/absolute/path/to/project bash -s -- --no-desktopUninstall while preserving configuration and data in a timestamped backup:
~/.local/share/fluxion/scripts/uninstall.shUse --purge only when the configuration and runtime data should also be
deleted.
Development install
For a source checkout used for Fluxion development:
git clone git@github.com:superposed-labs/fluxion-bus.git
cd fluxion-bus
python3 -m venv .venv
source .venv/bin/activate
pip install -e .
# Detect an executor and create a minimal .env with real paths.
fluxion init
# Check configuration, executor availability, and workspace authorization.
fluxion doctor
# Verify the local execution path with a read-only task.
fluxion run "Summarize this project and explain how to run its tests."Allow edits explicitly:
fluxion run --write "Fix the failing tests."Initialize Fluxion for another workspace:
fluxion init --workspace /absolute/path/to/project
fluxion doctor --workspace /absolute/path/to/project
fluxion run --workspace /absolute/path/to/project "Inspect this project."fluxion init creates a deliberately small .env; .env.example
mirrors that minimal shape for manual setup. For advanced manual configuration,
see .env.advanced.example,
Configuration, and scripts/install.sh.
MCP Delegation Quick Start
Register fluxion-mcp with the primary agent where you already work. Complete
client-specific examples for Claude Code, Codex, and Antigravity are in the
MCP reference.
Example Claude Code registration:
claude mcp add -s user \
-e FLUXION_ENV_FILE=<fluxion-repo>/.env \
-e FLUXION_WORKSPACE_ROOT=<fluxion-repo> \
-e FLUXION_DATA_DIR=<fluxion-repo>/data \
fluxion -- <fluxion-repo>/.venv/bin/fluxion-mcpThe primary agent can then delegate a focused subtask:
{
"agent": "claude",
"project": "web",
"profile": "inspect",
"mode": "read-only",
"prompt": "Investigate why the login form is submitting twice."
}Fluxion returns a run_id. The primary agent can inspect status, fetch the
result, cancel the run, review changed files, or revert a reviewed
workspace-writing run through the same MCP server.
For multi-project usage, configure project keys with
FLUXION_PROJECTS_FILE; see Project registry.
Quota Monitoring Quick Start
Web Console
If you installed the prebuilt app or used the installer, the console is ready. Start it directly:
fluxion-web # http://127.0.0.1:8765(If running from a Git clone or rebuilding static assets: cd web && npm install && npm run build && cd .. before running the command).
macOS Menu Bar App
If you downloaded the prebuilt Fluxion.dmg, drag it into /Applications and open it.
If building the menu bar app from your local source checkout (this compiles natively for your machine's architecture, whether Apple Silicon or Intel):
npm --prefix web ci
npm --prefix web run build
./desktop/build.sh
open desktop/Fluxion.appdesktop/build.sh reuses this Web console build on later runs. It does not
rebuild the frontend automatically.
The menu bar app can configure and start quota monitoring, automatic pings,
reset notifications, and companion services. The actual background auto-ping
and notification work is performed by fluxion-scheduler, which also runs
without the menu bar app on Linux.
The app can remain inside the repository or be copied to /Applications. When
launched outside the repository, it asks the user to select the Fluxion source
checkout and stores that path under ~/Library/Application Support/Fluxion/.
fluxion-schedulerSee Quota monitoring and Scheduler for provider sources, configuration, and always-on deployment.
Messaging Channels
fluxion-gateway accepts remote tasks from Slack, Telegram, WeChat, LINE, QQ,
and Feishu and submits them through the same router used by MCP and the local
CLI. It replies in the same conversation with execution status and the final
result.
fluxion-gatewaySee Configuration for channel and workspace settings.
Provider Gateway
fluxion-provider exposes Fluxion's local agent executors (such as Claude, Codex, or Antigravity) as an API provider endpoint (http://127.0.0.1:8787). External tools call it instead of a metered model API, and the work runs on a CLI you already have a subscription for. It speaks the OpenAI Responses API (Codex sub-agents) and the Anthropic Messages API (Claude Code).
fluxion-provider init
fluxion-provider serveRouting Codex's own sub-agents is discontinued on Codex 0.149 and later. Codex stopped letting an agent role choose its
model_provider(upstream commit1a6e07a4fe, #39299 — deliberate hardening, with a test that keeps it closed), so afluxion_workerspawn inherits the parent session's provider, runs on your own OpenAI model, and never reaches the gateway. Nothing errors. Fluxion refuses to install the integration on those versions. Usemcp__fluxion__run_subagentinstead; it launches local agents directly and is unaffected. Details in Provider Gateway.
On Codex 0.148 and earlier, to route Codex's sub-agents to Fluxion:
Open Fluxion Preferences → Provider Routing.
Confirm that Provider Gateway is running.
Under Codex Integration, click Install / Repair.
Choose the Codex model used for role capabilities and usage attribution, then install.
Restart Codex so it loads the new role files.
This installs fluxion_auto, fluxion_worker, fluxion_explorer, and
fluxion_reviewer. Name the role explicitly when delegating, for example:
“Use the fluxion_worker role to inspect this change.”
This native Codex integration is separate from registering the Fluxion MCP
server. MCP registration exposes mcp__fluxion__* tools; Codex Integration
routes Codex's own spawn_agent roles through the Provider Gateway. You can
use either integration independently.
For a CLI-only install:
fluxion-provider install-codex-config --model gpt-5.6-terraSee Provider Gateway for model selection, verification, read-only routing constraints, security token setup, and diagnostic commands.
Documentation
Architecture — full system diagram, surfaces, shared state, and project layout
Agent-assisted installation — step-by-step install instructions written for an AI agent to execute
MCP reference — client setup, tools, status states, cancel, and safe revert flows
Quota monitoring — provider sources, Web console, macOS app, privacy, and notifications
macOS app — release packaging, managed backend,
/Applicationsinstallation, and development overrideUsage statistics — agent-history coverage, independence from Fluxion delegation, cost estimates, and Fast-mode limitations
Scheduler — auto-ping, quota-reset triggers, cron rules, and deployment
Provider Gateway — local provider endpoint, auth tokens, and Codex integration
Configuration — executors, authorization, channels, Web UI, and environment variables
Deployment — launchd and systemd service templates
License
Apache License 2.0 — see also NOTICE.
Available Tools
13 toolscancel_subagent_runB
Request cancellation for an active sub-agent run in this MCP process.
Inputs: run_id (required). Returns: object
force_cancel_subagent_runA
Cancel a run that plain cancel_subagent_run cannot reach.
Use after cancel_subagent_run reports the run is unknown to this process, or a run has been non-terminal far longer than it should be.
Runs are owned by the Fluxion process that started them. If this process owns it, the request is delivered to the executor and terminates its whole process group. If another LIVE process owns it, this reports that owner and changes nothing — closing the record here would leave that agent running. If the owner is gone, the run is closed out as INTERRUPTED.
Inputs: run_id (required). Returns: object
get_fluxion_statusA
Which Fluxion is serving this session, and what it is doing.
Returns the installation actually in use (code root, .env path, data dir, version, git commit), the settings THIS process loaded at startup, its queue/worker state, other live Fluxion processes, and current workspace locks with their holders.
Use it when a config change appears to have had no effect: config is read once at startup, and a dev checkout and an installed copy can each have their own .env. config_file_changed_since_start=true means the file was edited after this process read it — restart to apply.
Inputs: no named parameters. Returns: object
get_projectC
Return one configured Fluxion project by key.
Inputs: project (required). Returns: object
get_task_resultA
Get a model-friendly result view, optionally including raw output.
With include_output=true, stdout/stderr are the agent's own output.
An executor runtime log (Antigravity's agy log) is returned separately
as executor_log, with its transport-level glog chatter filtered out —
folding it into stdout buried the agent's answer under hundreds of lines
of plumbing. Pass raw=true for the unfiltered persisted record.
Inputs: run_id (required), raw, include_output. Returns: object
get_task_statusA
Get model-friendly status and next action for a Fluxion run.
The default response is compact for polling. It includes the run status, terminal/cancel hints, progress_signal, recent_output_tail, log freshness, and next_action. Pass detail=true to include the full status view with repeated metadata such as timestamps, subagent metadata, changed_files, diff_summary, artifacts, and change_set_file.
Pass wait_ms > 0 to long-poll: the call blocks until the run reaches a terminal status or the wait elapses, then returns. wait_ms is capped at FLUXION_MCP_STATUS_MAX_WAIT_MS (default 60000 = 60s) to stay under the MCP client's per-call request timeout, so a still-running task just returns RUNNING — call again to keep waiting. This collapses a busy-poll loop into one blocking call per cap. Raise the env var if your client tolerates longer requests (set it to the client's tool timeout minus a margin).
Inputs: run_id (required), detail, wait_ms. Returns: object
list_agent_modelsA
List likely selectable models for one executor, sorted high to low.
Codex uses codex debug models when available. Antigravity uses agy models
when available. Claude Code does not expose a stable local model catalog, so
models[] contains known CLI aliases and the configured model. Every catalog is
enriched with the local price table when possible.
Pass a chosen models[].id to run_subagent(model=...). price_references[] is pricing context only and may not be valid as a model override. Provider, base URL, and auth remain settings-level config.
Inputs: agent, project. Returns: object
list_projectsA
List configured Fluxion projects available for sub-agent runs.
Inputs: no named parameters. Returns: object
list_subagent_runsC
List recent Fluxion sub-agent runs from the local task store.
Inputs: agent, limit, status, project, +1 more. Returns: object
reconcile_tasksA
Close out runs whose owning Fluxion process no longer exists.
A process that dies mid-run leaves its tasks recorded as RUNNING forever; this marks those INTERRUPTED so status polls stop reporting work that is not happening. Runs owned by a live process are never touched. This also happens automatically when a Fluxion process starts.
Inputs: no named parameters. Returns: object
revert_subagent_runC
Revert recoverable text-file changes recorded for one Fluxion run.
Inputs: run_id (required). Returns: object
run_subagentA
Submit a local Fluxion executor as a sub-agent task.
By default (wait_for_result=false) this returns as soon as the task is queued: you get a run_id — poll get_task_status and read get_task_result once terminal. Set wait_for_result=true for small smoke checks that should block until done; if the wait elapses first the task continues in the background (queued or running, bounded by task_timeout_sec) and is collected later via get_task_result with the run_id (the run is not canceled). For long or open-ended work prefer the default. timeout_sec only limits this blocking wait; it is not the executor runtime limit. The actual task execution cap is settings.task_timeout_sec.
agent: "auto" (default; uses the configured default) or one of "claude", "codex", "antigravity".
workspace: directory the agent runs in. With a configured project, "." is the
project root. WITHOUT a project (the default), pass an ABSOLUTE path to the
target repo — "." resolves against the server's workspace_root, not the caller's
cwd, so it is rarely what you want. Use list_projects to see configured projects.
profile/mode: for edit/fix/implement tasks set profile=implement and mode=workspace-write; the defaults profile=inspect / mode=read-only are intentionally read-only.
Workspace authorization: an unapproved workspace makes this call wait in place for the user to approve the notification Fluxion just raised (up to FLUXION_MCP_AUTHORIZATION_WAIT_MS, default 60s), then run normally — so an approved task usually needs no follow-up at all. If the user has not answered by then it returns error_code=WORKSPACE_NOT_AUTHORIZED with pending=true and an authorization_request_id. That is a pending HUMAN decision, not a transient failure, so retrying right away cannot succeed: call wait_for_authorization with that id instead of ending your turn to ask the user to report back. Retry this call only when the wait reports approved (pass the same id) or project-allowed (pass no id). If it reports denied, report the refusal instead of re-requesting.
task_name: optional free-form label for the run. It is shown as-is in the UI and also slugified into the agent-path segment (lowercased, non [a-z0-9] runs collapsed to _), so spaces, uppercase, and hyphens are all accepted — no need to pre-format it.
model: optional per-run model override for executors that support model selection. Leave empty to use the executor's configured/default model. To choose explicitly, call list_agent_models first and pass one of the returned models[].id values. Do not pass price_references[].id; those entries are pricing context only and may not be accepted by the executor. model is not a provider selector: provider, base URL, and auth remain settings-level configuration. Ping tasks keep their cheapest-model default unless model is explicitly set.
reasoning_effort: optional per-run reasoning depth, e.g. "low", "medium",
"high", "xhigh", "max". Valid values differ per model — read
models[].supported_reasoning_efforts from list_agent_models; asking for one
a model does not publish returns error_code=MODEL_UNRESOLVED listing what it
does publish, rather than silently running at a neighbouring effort. Leave
empty for the model's own default. Antigravity encodes effort in the model
id (gemini-3.7-flash-high); pass models[].id plus reasoning_effort and
Fluxion selects the published variant, or pass one of models[].variants
verbatim. The run payload reports what was actually used as
effective_model / effective_reasoning_effort.
thread / session_policy scope which executor session is reused. Default
(empty thread) = a FRESH isolated session per call: independent tasks don't
resume, so they can't inherit stale context or have their workspace edits
reconciled away by a resumed agent. To CONTINUE a prior run (resume — reuses
the agent's context, saving tokens), pass the SAME stable thread string on
each call. session_policy is "auto" (default), "continue", or "new" (force a
brand-new session even for a reused thread). Note: a resumed Antigravity run
may reconcile the workspace to its remembered state, so avoid editing the
workspace out-of-band between two same-thread runs.
Results: both are finalized only at terminal status (changed_files_available
stays false until then). changed_files is the authoritative, run-scoped list of
what THIS run touched — act on it. diff_summary.files mirrors that count, but its
additions/deletions are NOT measured per run and are always 0, flagged by
lines_counted=false — a whole-tree git diff --stat would fold in pre-existing
edits and earlier runs, so no line total is reported rather than a misleading
one. For exact line counts, run git diff over the changed_files yourself.
artifacts is not an inventory of files the run produced: it lists only files the agent explicitly declared for delivery via ACTIONS_JSON.upload_files, which it is prompted to do only when asked to send files. Screenshots and other by-products of the work appear in changed_files, not here.
Inputs: prompt (required), mode, agent, model, +14 more. Returns: object
wait_for_authorizationA
Wait for the user's decision on a pending workspace authorization request.
When run_subagent returns error_code=WORKSPACE_NOT_AUTHORIZED with pending=true, the workspace is waiting on a HUMAN: Fluxion has raised a notification and the user must approve it. Retrying the task immediately cannot succeed. Call this tool with the returned authorization_request_id instead of ending your turn to ask the user to report back — they approve while this call is waiting.
Pass wait_ms > 0 to long-poll: the call blocks until the request leaves "pending" or the wait elapses. wait_ms is capped at FLUXION_MCP_STATUS_MAX_WAIT_MS (default 60000 = 60s) to stay under the MCP client's per-call request timeout, so an unanswered request just comes back pending — call again to keep waiting, and tell the user you are waiting on their approval.
Act on status, not on the fact that the call returned:
approved: retry the original run_subagent with the same authorization_request_id (the returned retry_authorization_request_id).
project-allowed: the user granted the workspace permanently; retry the task WITHOUT authorization_request_id.
pending: still undecided; keep waiting or ask the user. Do NOT retry.
denied: the user refused. Do NOT retry and do NOT raise the same request again; report the refusal.
expired / consumed / active / not-found: this request id is finished. Submit a fresh run_subagent without an authorization_request_id if the work is still wanted.
next_action states the same thing in one sentence; should_retry is true only
when retrying will actually be authorized.
Inputs: authorization_request_id (required), wait_ms. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 13 tools
Most tools have clearly distinct purposes, and the lifecycle around run_subagent is well separated. The main risk is get_task_status vs get_task_result (both return run data with overlapping fields) and cancel_subagent_run vs force_cancel_subagent_run, though the latter is explicitly an escalation.
Tool names consistently follow snake_case verb_noun: list_projects, get_project, run_subagent, get_task_status, cancel_subagent_run. Minor stylistic variants like force_cancel_ and wait_for_ are still in the same pattern and do not create confusion.
13 tools is within the ideal range and each tool covers a distinct area of the subagent-run lifecycle, configuration, and maintenance. The count feels appropriate for the orchestration scope without redundant bulk.
The surface covers the full run lifecycle: submit, poll, retrieve results, cancel, force-cancel, and revert, plus supporting queries for projects, models, server status, authorization waits, and stale-run reconciliation. No obvious dead ends or missing critical operations.
Maintenance
Related MCP Connectors
A paid remote MCP for OpenAI Codex agent coordination MCP, built to return verdicts, receipts, usage
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
One MCP endpoint for Claude, GPT & Gemini: 100+ tools + no-code connectors + agent workers.
Chat, image, video, and audio models from many vendors behind one remote MCP server and one key.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceA local MCP server that connects AI coding agents (Claude Code, Codex, Cursor, etc.) on the same machine via a shared message bus, enabling them to chat, delegate tasks, and collaborate privately without cloud or internet.MIT
- FlicenseNot gradedqualityBmaintenanceA local MCP server that connects AI coding agents like Claude, Codex, and Gemini, enabling task routing, cross-model debates, and token-efficient context sharing without external APIs.19-
- AlicenseNot gradedqualityBmaintenanceAn MCP server that coordinates AI coding agents with mobile notifications, enabling task queues, inter-agent messaging, session monitoring, and human-in-the-loop approvals.MIT
- AlicenseNot gradedqualityCmaintenanceEnables Claude and Codex agents to delegate implementation, testing, research, or review tasks to each other through local MCP tools, while supporting persistent sessions, isolated editing workspaces, and reviewed integration. It also allows progress tracking, cancellation, model selection, and management handoff between providers.2MIT