codex-mcp-bridge

by hampsterx

Overview Schema Related Servers Score Discussions

TypeScript

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.9.1
Disambiguation4/5
Each tool has a distinct purpose, though codex/query and ping/mcpStatus have some overlap. Descriptions draw clear boundaries, but an agent could still confuse the general-purpose codex tool with its specialized variants like query or review.
Naming Consistency2/5
Naming follows no consistent pattern: listSessions and mcpStatus use camelCase, while the rest are single lowercase verbs or nouns (codex, search, query, ping, review, structured). Some are verbs, some nouns, and one is an adjective, making the set feel inconsistent.
Tool Count5/5
8 tools is appropriate for the bridge's scope, covering core execution plus specialized helpers without bloat. It sits comfortably within the typical 3-15 range and each tool earns its place.
Completeness4/5
The server covers core prompt execution, lightweight text analysis, web search, structured output, native review, session listing, and health/status checks. Minor gaps like session deletion or explicit file operations remain, but codex's own capabilities fill those holes.
Average 4.4/5 across 8 of 8 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 13 commits in the last 12 weeks
- Last stable release on August 2, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering safety and side effects. The description adds behavioral details such as default timeout (2 minutes), ability to increase for complex queries, and control of verbosity via maxResponseLength. It does not describe rate limits or API costs, but given the annotations, this is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear purpose statement followed by bullet-point tips. It is front-loaded with the main function. One sentence could be removed (e.g., 'Results include source URLs for verification' is stated twice), but overall it is 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?
Given the tool's complexity (web search with synthesis) and the richness of annotations, the description covers key aspects: response includes URLs, timeout behavior, and length control. No output schema exists, but the description explains return format sufficiently. Missing details like error handling are not critical for basic use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents all parameters. The description adds value by explaining when to adjust timeout and maxResponseLength, and how they affect behavior (e.g., complex queries may require multiple fetches). This goes beyond the schema's type/limit descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Web search via Codex CLI' and 'Searches the web and synthesizes a comprehensive answer with source URLs', providing a specific verb and resource. However, it does not explicitly distinguish from sibling tools like 'query' or 'review', which may have overlapping purposes.
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 lists concrete use cases (current information, documentation lookups, API references, research) and provides actionable tips (ask specific questions, use maxResponseLength, adjust timeout). It lacks explicit when-not-to-use or alternative tool references, but the context is clear enough for an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds that it generates a JSON response, but does not elaborate on behavior like error handling or idempotency. With annotations doing heavy lifting, the description is adequate but not exceptional.
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 concise sentences, front-loaded with the core action followed by use cases. No redundant or missing 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 6 parameters (2 required) and no output schema, the description covers the essential function and use cases. It could hint at return value more explicitly, but 'Generate a JSON response' suffices.
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% with detailed parameter descriptions. The tool description does not add additional meaning beyond what the schema already provides, meeting the baseline expectation.
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 it generates JSON based on a provided schema, naming specific use cases like data extraction and classification. It distinguishes from sibling tools (codex, search) by emphasizing structured output.
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 explicitly says 'Use for data extraction, classification, or any task needing machine-parseable output,' providing clear when-to-use guidance. However, it lacks explicit when-not-to-use or alternatives among siblings, but the context is strong.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds no behavioral context beyond what annotations provide; it does not explain what destructive actions might occur or what side effects the review has (e.g., modifying git state). It adequately describes the input scope but not the behavioral traits.
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 concise: two paragraphs and a bullet list with no filler. It front-loads the core purpose and practical usage, making it easy for an AI agent to parse efficiently.
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?
While the description covers purpose and usage, it lacks information about the output format. Since there is no output schema, the description could explain the review return structure (e.g., JSON with issues, severity, line numbers). Additionally, it gives no details on limitations or error handling.
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 each parameter already has a clear description. The description adds general tips (e.g., 'Set workingDirectory to the target git repository') but does not provide additional semantic detail beyond what the schema offers.
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 tool runs 'Codex CLI's native diff-aware review' and specifies it is for reviewing uncommitted changes, base branch diffs, or a single commit. It distinguishes from sibling tools like 'codex' by targeting MCP clients that cannot run shell commands.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('for MCP clients that cannot run shell commands but need native Codex review') and provides alternatives: 'Use the codex tool with sandbox "read-only" for free-form review prompts.' It also gives tips on setting workingDirectory and choosing mode.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Adds context beyond annotations by specifying the verification and reporting actions, without contradiction.
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 concise sentences with no waste, front-loading the purpose and key behavior.
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?
Adequately describes the tool for a health check with no parameters or output schema, though exact return format is not specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist; description adds value by stating the tool's function, meeting the baseline for 0-param tools.
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 tool verifies Codex CLI installation and authentication and reports versions and capabilities, distinguishing it from siblings like search or query.
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 this tool versus alternatives, but the purpose is implied through the health check nature.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already include destructiveHint=true and readOnlyHint=false. The description enhances this by detailing sandbox levels (read-only, workspace-write, full-auto), timeout behavior, and the impact of the files parameter on I/O and timeout. No contradictions with annotations.
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 well-organized: a one-sentence purpose, a bulleted capabilities list, a 'When to use a different tool' paragraph, and compact tips. Every sentence adds value, and the structure aids quick comprehension.
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?
For a tool with 10 parameters, no output schema, and complex capabilities, the description covers purpose, usage guidelines, tips, and behavioral context. It could be more explicit about the response format, but overall it provides sufficient context for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. However, the description adds significant practical context: line ranges for files, sandbox semantics, timeout defaults, reasoning effort mapping, and sessionId usage. This goes well beyond the schema descriptions.
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 'Execute a prompt via Codex CLI' and lists specific capabilities like code generation and refactoring. It distinguishes from siblings through the 'When to use a different tool' section and by emphasizing that this tool is for interacting with an AI coding agent with full project context.
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 provides a 'When to use a different tool' section that advises against using the files parameter for simple text analysis, and offers tips on setting workingDirectory, sandbox level, and session management. While it doesn't explicitly contrast with sibling tools, the guidance is clear and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnly and openWorld hints. Description adds context: no file reading, no repo exploration, no session state. It confirms non-destructive behavior and provides clarity on what the tool cannot do, which is valuable beyond the annotations.
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?
Description is well-structured: brief overview, explicit exclusions, use cases, and tips. Every sentence adds value. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 6 parameters and no output schema, the description fully covers the tool's behavior, parameter usage, and limitations. It is complete enough for an agent to use correctly without confusion.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All parameters are described in schema, but the description adds extra guidance: context must be inline text (not file paths), reasoningEffort levels mapped to depth, maxResponseLength as soft limit. This adds significant value beyond the schema descriptions.
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?
Description clearly states the tool is a lightweight query for analysis on existing text, distinguishing it from code execution (codex), search, and other siblings. It specifies what it does not do (file reading, repo exploration, session state).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly provides use cases (reviewing, critiquing, comparing) and when not to use (for code execution or file operations, use codex). Also includes tips on how to pass text and control reasoning effort.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint. Description adds that it returns only metadata (no prompts/responses) and focuses on active sessions, providing useful behavioral context beyond annotations.
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, front-loaded with the primary action, no redundant words. Highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameter-free tool with no output schema, the description fully covers purpose, return content, and usage context. Additional details on output format are unnecessary.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With zero parameters and 100% schema coverage, the description naturally contains no param details. Baseline score of 4 is appropriate; no further info needed.
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 tool lists active Codex sessions and specifies exactly what metadata is returned (IDs and timing). It distinguishes itself from siblings like codex by explaining its role in orchestration.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises when to use: 'Use to check available sessions before resuming with the codex tool's sessionId parameter.' No ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnly/destructive annotations, the description discloses significant behavioral traits: it is slower than normal calls, boots servers from ~/.codex/config.toml, produces no thread/session record in default mode, and starts an ephemeral thread in diagnostics mode. It also explains output interpretation ('unknown' is not a failure, 'degraded' warning semantics, builtIn vs configuredButUnreported). No contradiction with annotations.
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?
Although the description is long, it is exceptionally well-structured with a clear purpose statement, a behavioral caveat section, a two-mode breakdown, and an output interpretation guide. Every sentence adds necessary detail for a tool with no output schema. It is front-loaded with the most important information and uses scannable formatting.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity, the lack of an output schema, and the need to explain side effects, timing, and result semantics, the description is remarkably complete. It covers what the tool returns (initialized/unknown/failed), when failures can be detected, how to interpret warnings, and what side effects occur. No gaps remain for a competent agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds meaningful context beyond the schema for the diagnostics parameter, explaining that it 'starts an ephemeral thread to collect startup notifications' and is the only way to get explicit failure states. It also clarifies the default behavior (inventory only) which ties to the parameter's absence. Timeout and workingDirectory are left to the schema, but the added diagnostics context raises it above baseline.
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 opens with a specific verb and resource: 'Report what Codex's own app-server says about each MCP server it knows about: auth type, tool inventory, and whether the server initialized.' It clearly distinguishes itself from sibling tools by explicitly stating 'Unlike the other tools, this one deliberately does NOT suppress Codex's MCP servers,' making its unique purpose obvious.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides clear when-to-use context and even explains why alternatives would not work ('suppressing them would disable the thing being measured'). It also gives explicit guidance on choosing between default and diagnostics mode, stating diagnostics is 'the only way to get explicit failure states and error text.' This is strong usage guidance with exclusions and mode selection criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![codex-mcp-bridge MCP server](https://glama.ai/mcp/servers/hampsterx/codex-mcp-bridge/badges/card.svg)](https://glama.ai/mcp/servers/hampsterx/codex-mcp-bridge)

Score Badge

Copy to your README.md:

[![codex-mcp-bridge MCP server](https://glama.ai/mcp/servers/hampsterx/codex-mcp-bridge/badges/score.svg)](https://glama.ai/mcp/servers/hampsterx/codex-mcp-bridge)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/hampsterx/codex-mcp-bridge'

If you have feedback or need assistance with the MCP directory API, please join our Discord server