Skip to main content
Glama

English | 简体中文 | 日本語

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 agent
  • Route 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/Feishu
  • See 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 result

Remote 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, or agy

    • Codex: 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.13 through Homebrew when needed.

  • Node 18+ only when rebuilding the Web console frontend locally.

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/fluxion

The 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.app

On 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-desktop

The 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-desktop

Uninstall while preserving configuration and data in a timestamped backup:

~/.local/share/fluxion/scripts/uninstall.sh

Use --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-mcp

The 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.app

desktop/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-scheduler

See 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-gateway

See 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 serve

Routing Codex's own sub-agents is discontinued on Codex 0.149 and later. Codex stopped letting an agent role choose its model_provider (upstream commit 1a6e07a4fe, #39299 — deliberate hardening, with a test that keeps it closed), so a fluxion_worker spawn 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. Use mcp__fluxion__run_subagent instead; 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:

  1. Open Fluxion Preferences → Provider Routing.

  2. Confirm that Provider Gateway is running.

  3. Under Codex Integration, click Install / Repair.

  4. Choose the Codex model used for role capabilities and usage attribution, then install.

  5. 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-terra

See 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, /Applications installation, and development override

  • Usage 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 tools
cancel_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

    A3.8/5.0

    Scored across 13 tools

    Disambiguation4/5

    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.

    Naming Consistency5/5

    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.

    Tool Count5/5

    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.

    Completeness5/5

    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

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      A 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
    • F
      license
      Not graded
      quality
      B
      maintenance
      A 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
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      An 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
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables 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.
      2
      MIT