Which integrations are available for this server?

Provides asynchronous job management for OpenAI Codex CLI, allowing long-running code generation and editing tasks without blocking, including start, poll, list, and cancel operations.

How do I use codex-async-mcp?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@codex-async-mcp Start codex job to change format to number_to_currency in prorate_calculation_service.rb" 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.

de en es ja ko ru zh

codex-async-mcp

by benzkittisak

Overview Schema Source Related Servers Discussions Admin

Python

Local

agent-async-mcp

Local MCP server that runs Codex, Cursor, and Gemini CLI tasks asynchronously — returns a job_id immediately instead of blocking, so the orchestrating agent never hits the MCP 60-second timeout.

How it works

Claude (orchestrator)
  │
  ├─ codex_start(prompt, cwd)  →  job_id (instant)
  │
  └─ codex_wait(job_id)        →  blocks up to 50 s, returns result
                                   loop again on timeout

A sequential queue ensures only one agent process runs at a time. Jobs are persisted in SQLite so the queue survives server restarts.

Related MCP server: codex-mcp-server

Install

curl -fsSL https://raw.githubusercontent.com/benzkittisak/claude-codex-mcp/master/install.sh | bash

The installer will:

Clone this repo to ~/.local/share/agent-async-mcp/
Create an isolated Python venv
Symlink agent-async to ~/.local/bin/
Detect Claude Code, Codex, Cursor, Claude Desktop and ask which to register

Uninstall:

curl -fsSL https://raw.githubusercontent.com/benzkittisak/claude-codex-mcp/master/install.sh | bash -s uninstall
# or, if already installed:
agent-async uninstall

CLI

agent-async list-agents              # show detected / registered agents
agent-async add-agent claude-code    # register with Claude Code CLI
agent-async add-agent codex          # register with Codex CLI
agent-async add-agent cursor         # register with Cursor IDE
agent-async add-agent claude-desktop # register with Claude Desktop
agent-async remove-agent <agent>     # unregister
agent-async status                   # open real-time job monitor
agent-async update                   # pull latest + reinstall
agent-async check-update             # check without installing
agent-async enable-auto-update       # schedule daily auto-update (09:00)
agent-async disable-auto-update      # remove scheduled auto-update
agent-async uninstall                # remove everything

Requirements

Python 3.11+
One or more agent CLIs: codex, cursor, gemini (optional — only needed for the tools you use)
Claude Code CLI (recommended orchestrator)

MCP Tools (13 total)

Codex

Tool	Description
`codex_start(prompt, cwd, approval_policy?, context_files?)`	Queue a Codex task → returns `job_id` instantly
`codex_wait(job_id, timeout_seconds=50)`	Block until done; loop on `{"status":"timeout"}`
`codex_await_any(timeout_seconds=50)`	Block until ANY queued job completes

Cursor

Tool	Description
`cursor_start(prompt, cwd, approval_policy?, context_files?)`	Queue a Cursor headless task → `job_id`
`cursor_wait(job_id, timeout_seconds=50)`	Block until done

Gemini

Tool	Description
`gemini_start(prompt, cwd, approval_policy?, context_files?)`	Queue a Gemini CLI task → `job_id`
`gemini_wait(job_id, timeout_seconds=50)`	Block until done
`gemini_confluence_start(title, cwd, ...)`	Ask Gemini to draft/publish a Confluence page
`gemini_pr_start(cwd, pr_goal, ...)`	Ask Gemini to draft/publish a PR

Shared / Queue

Tool	Description
`job_list(limit=20)`	List recent jobs (all agents), newest first
`job_cancel(job_id)`	Cancel running or pending job
`queue_status()`	`{"busy": bool, "pending_count": int}`
`agent_notify_done(job_id, summary?)`	Called BY an agent to signal completion

`approval_policy` values

Value	Behavior
`full-auto`	No prompts, no sandbox (use for automation)
`auto-edit`	Auto-applies edits
`suggest`	Read-only — pauses for interactive input (avoid in automation)

Permissions (settings.local.json)

Add to your Claude Code project's .claude/settings.local.json:

{
  "permissions": {
    "allow": [
      "mcp__agent-async__codex_start",   "mcp__agent-async__codex_wait",
      "mcp__agent-async__cursor_start",  "mcp__agent-async__cursor_wait",
      "mcp__agent-async__gemini_start",  "mcp__agent-async__gemini_wait",
      "mcp__agent-async__queue_status",  "mcp__agent-async__job_list",
      "mcp__agent-async__job_cancel",    "mcp__agent-async__agent_notify_done",
      "mcp__agent-async__codex_await_any"
    ]
  }
}

Usage pattern

# Start a job (returns immediately)
result = codex_start(
    prompt="In app/services/foo.rb line 42, change X to Y. Do not change anything else.",
    cwd="/path/to/repo",
    approval_policy="full-auto"
)
job_id = result["job_id"]

# Wait in a loop (each call blocks up to 50 s)
while True:
    result = codex_wait(job_id, timeout_seconds=50)
    if result["status"] == "timeout":
        continue
    break  # "done" | "error" | "cancelled"

Job data

Jobs are persisted in ~/.agent-async/:

~/.agent-async/
  queue.db          ← SQLite: job metadata, status, token usage
  jobs/<job_id>/
    output.txt      ← stdout + stderr from the agent process

Troubleshooting

`agent-async: command not found`

~/.local/bin not in PATH. Run:

source ~/.zshrc   # or ~/.bashrc

Or open a new terminal. The installer adds it automatically.

`status: "error"` immediately after `*_start`

The agent CLI failed to start. Check output:

cat ~/.agent-async/jobs/<job_id>/output.txt

Message	Fix
`command not found: codex`	Install codex: `npm install -g @openai/codex`
`command not found: gemini`	Install gemini CLI from github.com/google-gemini/gemini-cli
`permission denied`	`cwd` doesn't exist or is inaccessible

`status: "running"` forever

The subprocess is hung. Most common cause: approval_policy="suggest" waiting for interactive input. Always use "full-auto" for automation.

agent-async status   # open monitor to see live state

Cancel a stuck job:

job_cancel(job_id="<job_id>")

Old jobs filling up disk

find ~/.agent-async/jobs -maxdepth 1 -type d -mtime +7 -exec rm -rf {} +

Project structure

agent-async-mcp/
├── install.sh
├── mcp-monitor.py
├── pyproject.toml
└── src/
    └── agent_async_mcp/
        ├── server.py       # MCP entry point, tool definitions
        ├── job_manager.py  # queue, spawn, wait, cancel
        ├── db.py           # SQLite schema + helpers
        ├── config.py       # paths, timeouts, agent binaries
        └── cli.py          # agent-async CLI

Development

git clone https://github.com/benzkittisak/claude-codex-mcp
cd claude-codex-mcp
pip install -e ".[dev]"
pytest tests/ -v

Available Tools

4 tools

codex_cancelA

Cancel a running codex job by sending SIGTERM to the subprocess.

ParametersJSON Schema

Name	Required	Description	Default
`job_id`	Yes	The job_id returned by codex_start.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses that cancellation is done by sending SIGTERM to the subprocess, which is a key behavioral trait. It does not cover edge cases like job already finished, but the main behavior is well communicated.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single 12-word sentence, front-loaded with the action, and contains no wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (one parameter, single action), the description is nearly complete. It could mention what happens if the job is not running, but the output schema likely handles error responses.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already describes the only parameter (job_id) with 100% coverage. The description adds no new semantic information beyond what the schema provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Cancel') and resource ('running codex job'), and clearly distinguishes from siblings like codex_list, codex_poll, and codex_start.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implicitly states when to use (to cancel a running job with a job_id from codex_start) but does not explicitly state when not to use or provide alternative scenarios. However, the simplicity of the action mitigates the need for extensive guidelines.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

codex_listA

List recent codex jobs with their status and prompt summaries.

ParametersJSON Schema

Name	Required	Description	Default
`limit`	No	Max number of jobs to return (most recent first). Default: 20.

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It only states it lists jobs with status and summaries, but lacks details on pagination, ordering (though limit param says 'most recent first'), rate limits, or side effects. The description is too minimal for full transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, no redundant words, front-loaded with the core action. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of an output schema (status and prompt summaries mentioned), the description is somewhat complete for a simple list operation. However, it lacks details on error handling, empty results, or additional behavioral context that would fully inform an agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% for the single parameter 'limit', and the schema itself provides a description including default and ordering. The tool description adds no extra meaning beyond what the schema already conveys.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the tool lists recent codex jobs, including status and prompt summaries. The verb 'list' and resource 'recent codex jobs' are specific and distinguish from sibling tools (cancel, poll, start) which are different actions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use or avoid this tool. The purpose is implied by the name and description, but no alternatives or exclusions are mentioned. Siblings have distinct purposes, so usage is inferred but not clarified.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

codex_pollA

Poll the status and output of a running (or finished) codex job.

ParametersJSON Schema

Name	Required	Description	Default
`job_id`	Yes	The job_id returned by codex_start.
`tail_lines`	No	How many trailing lines of output to return. Default: 100.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description states the purpose but lacks details on behavioral traits such as whether the tool is idempotent or safe to call repeatedly. Since annotations are absent, the description carries the burden, and it only provides minimal transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no extraneous words. It efficiently conveys the tool's purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of an output schema, the description does not need to explain return values. It covers the essential purpose and scope, though it could mention that the tool can be called multiple times safely.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, and the description adds no additional meaning beyond what the schema already provides for the two parameters. The description's mention of 'output' hints at tail_lines, but this is redundant with the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Poll' and the resource 'status and output of a running (or finished) codex job', which is specific and distinguishes it from sibling tools like codex_start, codex_cancel, and codex_list.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage after a job is started, but does not explicitly provide when-not-to-use or alternatives. The context is clear enough for an agent to infer appropriate usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

codex_startA

Start a codex task asynchronously in the background.

Returns a job_id immediately — does not block or timeout. Use codex_poll(job_id) to check progress.

ParametersJSON Schema

Name	Required	Description	Default
`prompt`	Yes	The task description to pass to codex.
`cwd`	Yes	Absolute path to the working directory for codex.
`approval_policy`	No	One of 'suggest', 'auto-edit', 'full-auto'. Default: 'suggest'.	suggest

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. Discloses async, non-blocking, immediate return of job_id. Does not mention side effects or auth, but core behavior is adequately covered.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, no wasted words. Front-loaded with purpose and key behavior. Highly efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Has output schema. Describes async nature and returns job_id. Could mention cancellation via sibling codex_cancel, but sufficient for a simple start tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline 3. Description does not add meaning beyond schema; each parameter is defined in schema. No extra context provided.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the verb 'Start', resource 'codex task', and key behavior 'asynchronously in the background'. Distinguishes from siblings by mentioning that codex_poll is used to check progress.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit guidance to use codex_poll for progress checking. Implicitly tells when to use this tool (async tasks) but lacks explicit when-not-to-use or alternatives beyond polling.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

4 tool updatesv0.1.0Apr 30, 2026
- First observedcodex_cancel
- First observedcodex_list
- First observedcodex_poll
- First observedcodex_start

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4.2/5.0

Scored 2026-04-30 02:15 across 4 tools

Disambiguation5/5

Each tool has a distinct purpose: start, list, poll, and cancel. There is no overlap in functionality, and the descriptions clearly differentiate them.

Naming Consistency5/5

All tools follow a consistent 'codex_verb' pattern using snake_case, making it predictable for an agent to infer tool behavior from the name.

Tool Count5/5

Four tools cover the essential operations for managing async jobs (start, list, poll, cancel) without redundancy or missing critical actions.

Completeness5/5

The tool set covers the full lifecycle of an async job: initiating (start), monitoring (poll, list), and termination (cancel). No obvious gaps are present.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Related MCP Connectors

Tanjiren MCP Server
app.tanjiren
Hosted MCP server for task-first delegation to remote workstations and workers.
Agent Orchestration Autonomous Agents Developer Tools
2
mcp-serverOAuth
com.ffmpeg-micro
MCP server for the FFmpeg Micro video transcoding API — create, monitor, download transcodes.
Multimedia Processing App Automation
21
MANDATE Credential Broker B
io.github.projetnanocorp
MCP server for mandates, delegation, policy-gated execution, credential grants, and audit.
Security
111
KodyOAuth
io.github.kentcdodds
Personal assistant MCP server with search, execute, packages, jobs, secrets, and integrations.
Developer Tools Code Execution Command Line
2627

Related MCP Servers

codex-mcp-server
Coding Agents Code Execution
shilong20
A
license
A
quality
D
maintenance
MCP server for Codex CLI — tmux persistence, git worktree isolation, async dispatch.
Updated 5 months ago (2026-04-07 10:18 UTC)
4
79 PyPI
1
MIT
codex-mcp-server
Coding Agents Code Execution
Pigowenhsiao
A
license
Not graded
quality
D
maintenance
Wraps OpenAI Codex CLI as an MCP server, exposing 8 Codex tools (exec, review, skill list, skill run, status, poll, list jobs, kill) as named tools for use with pi or codex.
Updated 3 months ago (2026-06-04 02:17 UTC)
577 npm
ISC
codex-mcp-bridge
Code Execution Search Developer Tools
hampsterx
A
license
A
quality
A
maintenance
MCP server that wraps Codex CLI as a subprocess, exposing code execution, web search, and structured output as Model Context Protocol tools.
Updated 17 days ago (2026-08-29 07:41 UTC)
8
37 npm
3
MIT
engineering-bridge
Coding Agents Command Line Code Execution
wudy29
A
license
Not graded
quality
A
maintenance
A local STDIO MCP server that bridges MCP clients to the Codex CLI by sending instructions to a configured workspace, exposing task run, status, and result tools with a read-only sandbox and no remote transport.
Updated 5 days ago (2026-09-11 02:48 UTC)
124
MIT

agent-async-mcp

How it works

Install

CLI

Requirements

MCP Tools (13 total)

Codex

Cursor

Gemini

Shared / Queue

approval_policy values

Permissions (settings.local.json)

Usage pattern

Job data

Troubleshooting

agent-async: command not found

status: "error" immediately after *_start

status: "running" forever

Old jobs filling up disk

Project structure

Development

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Tool Schema Changelog

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

`approval_policy` values

`agent-async: command not found`

`status: "error"` immediately after `*_start`

`status: "running"` forever