codex-mcp-system
Allows generating and editing images through OpenAI's Codex integrated image generation ($imagegen / GPT Image 2), using the authenticated ChatGPT account and saving resulting files locally with metadata and optional inline previews.
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., "@codex-mcp-systemGenerate an image of a sunset over the ocean with a silhouette of a person."
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.
codex-mcp-system
codex-mcp-system é um servidor MCP local, em Python, que permite a um cliente MCP pedir geração e edição de imagens à capacidade integrada $imagegen do Codex. Ele inicia o processo oficial codex app-server por stdio, usa o login ChatGPT que o próprio Codex gerencia e devolve o arquivo final com metadados e, quando couber, uma prévia MCP inline.
Projeto pessoal e não oficial. Não é desenvolvido, mantido nem suportado pela OpenAI.
Cliente MCP
└─ stdio → codex-mcp-system
└─ stdio/JSONL → codex app-server
└─ login ChatGPT → $imagegen / GPT Image 2Cota do Codex versus OpenAI API
A geração integrada usa GPT Image 2 e é contabilizada nos limites gerais do Codex associados ao plano ChatGPT. Este projeto remove OPENAI_API_KEY apenas do ambiente do subprocesso e bloqueia autenticação apikey antes de gerar.
A formulação correta é: sem cobrança da OpenAI API; descontado da franquia/cota do Codex associada ao plano ChatGPT. Isso não significa custo monetário zero: a assinatura, a cota e eventuais limites do plano continuam aplicáveis. Não há fallback automático para a API paga.
Documentação oficial consultada:
Related MCP server: MetaRouter Image MCP
Pré-requisitos
macOS ou outro sistema com o executável
codexcompatível;Python 3.11 ou superior;
conta ChatGPT com acesso ao Codex e à geração de imagens;
um cliente compatível com MCP por
stdio.
O App Server é experimental; esta versão foi validada com codex-cli 0.153.4. O servidor MCP usa a linha estável v2 do SDK MCP para Python.
Instalação
Com venv e pip:
cd /Users/baker/repos-own/codex-mcp-system
python3 -m venv .venv
./.venv/bin/python -m pip install --upgrade pip
./.venv/bin/python -m pip install -e .Para desenvolvimento:
./.venv/bin/python -m pip install -e '.[dev]'uv também funciona:
uv venv --python 3.11 .venv
uv pip install --python .venv/bin/python -e '.[dev]'Login oficial com ChatGPT
Use o fluxo fornecido pelo Codex; o projeto não implementa OAuth próprio nem lê o armazenamento de credenciais:
codex loginOu peça ao utilitário para executar o mesmo fluxo e depois rodar o diagnóstico:
./.venv/bin/codex-mcp-system loginDiagnóstico sem consumo de imagem
./.venv/bin/codex-mcp-system doctorO doctor verifica Python, executável e versão do Codex, inicialização do App Server, account/read sanitizado, modo de autenticação, plano quando disponível, presença local de $imagegen e escrita no diretório de saída. Ele não gera imagem e nunca mostra email, token, cookie, cabeçalho ou URL OAuth.
Um resultado pronto contém, entre outros campos:
{
"auth_mode": "chatgpt",
"imagegen_available": true,
"api_billing_blocked": true,
"app_server_initialized": true,
"doctor_ok": true
}Executar por stdio
./.venv/bin/codex-mcp-system serveO stdout fica reservado exclusivamente ao protocolo MCP. Logs vão para stderr. Ao desconectar o cliente, o servidor encerra o App Server filho de forma limpa.
Configuração de um cliente MCP
Bloco pronto para copiar:
{
"mcpServers": {
"codex-mcp-system": {
"command": "/Users/baker/repos-own/codex-mcp-system/.venv/bin/codex-mcp-system",
"args": ["serve"],
"env": {
"CODEX_MCP_CODEX_BIN": "/Applications/ChatGPT.app/Contents/Resources/codex",
"CODEX_MCP_OUTPUT_DIR": "/Users/baker/Pictures/codex-mcp-system"
}
}
}
}Não adicione OPENAI_API_KEY. O mesmo exemplo está em examples/mcp-client-config.json.
Usar no Claude Code
O passo a passo completo, incluindo instalação limpa, cadastro, verificação e solução de problemas, está em docs/instalacao-claude-code.md.
O Claude Code inicia este servidor automaticamente quando precisa dele. Não é necessário deixar
serve aberto em outro terminal nem manter uma conversa do Codex aberta. O executável codex
e o login ChatGPT devem continuar disponíveis no computador.
Neste computador, o ambiente virtual já está instalado. Primeiro confira o login sem gerar imagem:
CODEX_MCP_CODEX_BIN=/Applications/ChatGPT.app/Contents/Resources/codex \
/Users/baker/repos-own/codex-mcp-system/.venv/bin/codex-mcp-system doctorSe o resultado mostrar doctor_ok: true, cadastre o servidor uma única vez:
claude mcp add \
--env CODEX_MCP_CODEX_BIN=/Applications/ChatGPT.app/Contents/Resources/codex \
--env CODEX_MCP_OUTPUT_DIR=/Users/baker/Pictures/codex-mcp-system \
--transport stdio --scope user \
codex-mcp-system -- \
/Users/baker/repos-own/codex-mcp-system/.venv/bin/codex-mcp-system serveO escopo user disponibiliza o servidor em todos os seus projetos do Claude Code. Para disponibilizar
somente no projeto atual, troque por --scope local. Os caminhos acima são os desta instalação;
em outro computador, use os caminhos retornados por command -v codex e pelo seu ambiente virtual.
Mantenha --transport e --scope depois de --env: isso evita que a CLI interprete o nome do servidor
como mais uma variável de ambiente.
O cadastro também vale para sessões locais da aba Code do aplicativo Claude. A tela de "Add custom connector", que pede uma URL HTTPS, é destinada a conectores remotos. Para este MCP local, use o cadastro acima e abra uma nova sessão Code após adicionar.
Confira o cadastro:
claude mcp get codex-mcp-systemAbra uma nova sessão de claude e digite /mcp para conferir a conexão e as quatro ferramentas.
Então peça, em linguagem natural:
Use codex-mcp-system para verificar se minha conta está pronta, sem gerar imagem.
Para gerar:
Use codex-mcp-system para gerar uma foto de um vaso azul sobre uma mesa de madeira, em qualidade low. Salve como vaso-azul.png e me informe o caminho.
Para editar:
Use codex-mcp-system para editar /Users/baker/Pictures/codex-mcp-system/vaso-azul.png. Troque apenas o fundo por branco e preserve o vaso.
Consultas de status não geram imagens. Pedidos de geração e edição usam a cota do Codex da conta ChatGPT autenticada. O uso do próprio Claude continua sujeito à sua configuração e ao seu plano. O arquivo final fica na pasta indicada, mesmo quando o cliente não mostra uma prévia inline.
Para remover somente a conexão do Claude Code:
claude mcp remove --scope user codex-mcp-systemSintaxe e escopos conferidos com Claude Code 2.1.105 e com a documentação oficial de MCP do Claude Code.
Ferramentas MCP
O servidor publica exatamente quatro ferramentas:
codex_account_status: confirma login, plano, Codex e$imagegen;generate_image: gera uma imagem;edit_image: edita uma ou mais imagens locais, com máscara opcional;imagegen_status: informa backend, saída e limites; o probe opcional não consome geração.
Exemplo de generate_image:
{
"prompt": "Um pequeno vaso de cerâmica azul sobre uma mesa clara, luz suave de estúdio.",
"size": "1024x1024",
"quality": "medium",
"background": "opaque",
"output_format": "png",
"output_filename": "vaso-azul.png",
"include_inline": true
}Exemplo de edit_image:
{
"prompt": "Troque apenas o fundo por cinza-claro. Preserve objeto, recorte, sombras e cores.",
"image_paths": ["/Users/baker/Pictures/produto.png"],
"mask_path": null,
"size": "auto",
"quality": "medium",
"background": "opaque",
"output_format": "png",
"output_filename": "produto-fundo-cinza.png",
"include_inline": true
}Cada sucesso retorna caminho absoluto, nome, MIME detectado, largura, altura, bytes, backend, confirmação chatgpt e aviso de cota. Uma ImageContent base64 é incluída até o limite configurado; acima dele, a resposta traz um ResourceLink local e sempre mantém o caminho absoluto no objeto estruturado.
Diretório de saída e configuração
Sem configuração, a saída diária é:
~/Pictures/codex-mcp-system/YYYY-MM-DD/Se CODEX_MCP_OUTPUT_DIR for definido, ele é usado como diretório final exato.
Variável | Padrão | Uso |
| diretório diário acima | arquivos finais |
|
| timeout total do turno |
|
| executável do Codex |
|
| logs em |
|
| limite da prévia inline |
|
| qualquer valor |
Suposições documentadas: o override de saída é o diretório final, não recebe sufixo de data; nomes existentes nunca são sobrescritos e ganham -2, -3 etc.; dimensões são requisitos enviados ao backend, mas a dimensão efetiva sempre é medida no arquivo e pode ser normalizada pela geração integrada.
Segurança e limites
somente MCP por
stdio; nenhuma porta, API HTTP ou WebSocket é aberta;OPENAI_API_KEYé removida apenas do ambiente do App Server filho; o ambiente global e arquivos do usuário não são alterados;o projeto não lê
~/.codex/auth.jsonnem copia credenciais;prompts têm até 8.000 caracteres e são serializados como dados não confiáveis, separados das instruções de desenvolvedor;
referências aceitas: PNG, JPEG e WebP validados por conteúdo, até 4 arquivos, 20 MiB cada e 50 MiB no total incluindo máscara;
arquivos animados são rejeitados;
nomes não aceitam caminhos, absolutos,
..ou separadores;publicação final é atômica e não segue links simbólicos para sobrescrever destinos;
a versão inicial serializa gerações: um trabalho de imagem por vez;
o cliente que receber acesso ao servidor poderá consumir a cota do Codex e criar arquivos locais;
não há relay público, scraping de
chatgpt.com, reutilização de cookies nem fallback PAYG.
Em termos simples, máscara é uma segunda imagem que marca onde fazer uma alteração — por exemplo,
a região do fundo de uma foto. Ela é opcional. Para gerar imagens novas ou pedir uma edição comum,
omita mask_path: basta descrever a alteração e fornecer a imagem original. As marcações servem como
guia visual; este fluxo não garante que cada pixel fora delas permaneça idêntico.
O App Server recebe esse guia como mais uma imagem local (localImage), pois o schema desta versão
não oferece um campo exclusivo para máscara.
O servidor valida nomes de arquivo antes de iniciar uma geração e confirma o login novamente quando o pedido sai da fila. Um cancelamento MCP ou timeout solicita a interrupção do turno; se o processo não responder ou não devolver o ID do turno, o servidor encerra o filho. Isso não desfaz a cota já consumida. A conversa efêmera é liberada ao final, e uma geração submetida nunca é repetida automaticamente.
As ferramentas de shell são desabilitadas na configuração da conversa de imagem. O provedor é fixado
em openai com fallback de provedor desabilitado; a autenticação precisa ser chatgpt imediatamente
antes do envio. As instruções restritivas e o sandbox complementam essas medidas.
Imagens têm também limite de 40 milhões de pixels após descompressão e são abertas integralmente para detectar arquivos truncados. Pillow é usado somente para validação e metadados: se o backend devolver outro formato, o servidor informa o erro, sem converter a imagem ou gerar outra automaticamente.
Smoke test
Este comando faz uma geração real em qualidade low e consome a cota geral do Codex:
./.venv/bin/codex-mcp-system smoke-testNão o repita desnecessariamente. Ele se recusa a executar com autenticação apikey.
Na prova de conceito de 2026-09-06, o backend CodexAppServerBackend gerou com sucesso o cubo vermelho solicitado. O arquivo retornado era PNG válido, 1.687.720 bytes e 1254×1254 pixels; a dimensão efetiva ilustra a normalização mencionada acima.
Na revisão seguinte, foram verificados novamente o doctor, as quatro ferramentas MCP e a criação
e liberação de conversa com as restrições atualizadas, usando o App Server real sem iniciar um turno
gerador. Geração e edição completas por MCP, cancelamentos e falhas são cobertos também pelo backend
simulado. A edição ainda não foi validada com geração real; nenhum teste simulado deve ser interpretado
como prova da qualidade de uma edição produzida pelo modelo.
Solução de problemas
Executável 'codex' não encontrado
: Abra/instale o Codex ou defina CODEX_MCP_CODEX_BIN com o caminho absoluto do executável.
Autenticação por API key detectada e bloqueada
: Remova OPENAI_API_KEY da configuração do cliente MCP e execute codex login escolhendo ChatGPT.
$imagegen não está disponível
: Confirme plano e políticas do workspace no Codex. O projeto não substitui esse caminho por API paga.
Limite de uso do Codex atingido
: Aguarde a renovação indicada pelo produto. O servidor não tenta contornar limites.
Timeout
: A geração não é repetida automaticamente depois que o turno começa, pois um retry poderia consumir a cota duas vezes. Aumente CODEX_MCP_TIMEOUT_SECONDS apenas para a próxima chamada.
turn/start ou evento incompatível
: Atualize o Codex e rode doctor. O cliente usa os métodos oficiais e foi construído contra os schemas da versão instalada.
Confirmar que não usa API key
Não inclua
OPENAI_API_KEYno bloco MCP.Mantenha
CODEX_MCP_ALLOW_API_KEY=falseou simplesmente omita a variável.Rode
doctore confira:auth_mode: "chatgpt",api_key_forwarded_to_app_server: false,api_billing_blocked: trueedoctor_ok: true.
O campo api_key_present_in_parent é apenas um booleano diagnóstico. Mesmo que outro software tenha definido uma chave no shell pai, o valor nunca é impresso e a chave não é encaminhada ao App Server.
Desenvolvimento
./.venv/bin/ruff format --check .
./.venv/bin/ruff check .
./.venv/bin/pytest -qA suíte normal usa um App Server falso e não consome cota. Testes reais ficam fora da execução unitária comum.
Desinstalação
Remova somente o ambiente virtual e o checkout deste projeto usando o gerenciador de arquivos ou comandos direcionados aos caminhos exatos. Depois remova o bloco codex-mcp-system do cliente MCP.
Não execute logout e não apague ~/.codex: a desinstalação deste projeto não precisa remover, ler nem alterar as credenciais gerenciadas pelo Codex.
Available Tools
4 toolscodex_account_statusBRead-only
Verifica autenticação ChatGPT, plano, Codex e disponibilidade de $imagegen.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=false, and the description's 'verifica' is consistent with a read-only check. The description adds some behavioral context by enumerating what is verified (auth, plan, Codex, imagegen availability), but does not disclose response shape or failure/edge behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence with no filler, front-loading the verb and main subjects. The cryptic '$imagegen' prefix looks like an unresolved template variable, which slightly detracts from polish, but overall the description is appropriately sized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, read-only status tool this is mostly adequate: it names what is checked and the annotations cover the safety profile. However, with no output schema, it would benefit from hinting at what the response contains, and the $imagegen term plus sibling overlap with imagegen_status remain unresolved.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4 per rubric. The description need not explain parameter semantics, and the empty schema confirms no arguments are required.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Verifica' (verifies) and names its targets: ChatGPT authentication, plan, Codex, and $imagegen availability. The scope is clear, but it does not differentiate from the sibling imagegen_status, which likely also reports on imagegen availability.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus imagegen_status, generate_image, or edit_image. With a closely related sibling like imagegen_status, the potential for mis-selection is real and unaddressed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
edit_imageB
Edita imagens locais com $imagegen, preservando o que o prompt não mandar alterar.
| Name | Required | Description | Default |
|---|---|---|---|
| size | No | auto | |
| prompt | Yes | Alterações desejadas e partes a preservar | |
| quality | No | medium | |
| mask_path | No | Imagem opcional que marca a área a editar; normalmente omita | |
| background | No | auto | |
| image_paths | Yes | De uma a quatro imagens PNG/JPEG/WebP locais | |
| output_format | No | png | |
| include_inline | No | ||
| output_filename | No | ||
| output_directory | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the operation is not read-only and not idempotent, so the safety profile is covered. The description adds value by disclosing the preservation semantics and the $imagegen dependency, but it doesn't disclose output file behavior, whether inputs get overwritten, or any other side effects of the edit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence with no filler words, front-loading the verb and the core behavioral guarantee. It is lean and well-ordered, though it is arguably too terse for a 10-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutating, closed-world tool with 10 parameters, no output schema, and only 30% schema description coverage, a one-sentence description is under-specified. It omits output handling, mask-based editing semantics, image count limits, and what happens to the files after editing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 30%, so 7 of 10 parameters (size, quality, background, output_format, include_inline, output_filename, output_directory) lack schema documentation. The description does not compensate: it mentions editing, preservation, and local images, but never explains the mask, output, or formatting parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource ('edits local images') and adds a distinctive behavioral clause: it preserves anything the prompt doesn't ask to change. This clearly differentiates it from the sibling generate_image, which creates new images rather than editing existing ones.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the usage context — modify existing local images while keeping unspecified content intact — but it never explicitly names alternatives or exclusion conditions. An agent must infer that generate_image is the right choice for new image creation; no when-to-use vs. when-not-to-use guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_imageC
Gera uma imagem com $imagegen e a cota do Codex da conta ChatGPT.
| Name | Required | Description | Default |
|---|---|---|---|
| size | No | auto ou WIDTHxHEIGHT compatível | 1024x1024 |
| prompt | Yes | Descrição visual; máximo de 8000 caracteres | |
| quality | No | medium | |
| background | No | auto | |
| output_format | No | png | |
| include_inline | No | ||
| output_filename | No | Somente nome do arquivo, sem diretórios | |
| output_directory | No | Diretório local explícito; usa a configuração se omitido |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already signal a non-read-only, non-idempotent mutation, and the description adds that generation consumes Codex quota from the ChatGPT account, a useful resource/rate context. However, it does not disclose output file behavior, failure modes, or whether edits are reversible, so it only partially carries the behavioral burden.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no filler or redundancy. It loses a point only because the '$imagegen' phrasing is cryptic and the sentence omits useful context that could be included without bloat.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an 8-parameter tool with no output schema, the description is far too thin: it omits return behavior, how the output file is produced, the significance of Codex quota, and any relation to the sibling tools. It is minimally usable but leaves major gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 50% schema description coverage, the schema leaves quality, background, output_format, and include_inline undocumented, and the description adds no parameter-level meaning beyond the word 'imagem'. It therefore fails to compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource ('Gera uma imagem') and adds a distinctive implementation/quota detail ('com $imagegen e a cota do Codex'), so an agent can tell it is a generation action rather than a status check. It does not explicitly contrast with edit_image, so it falls short of full sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to choose generate_image over siblings like edit_image or when to first check codex_account_status. The quota mention hints at a prerequisite, but no explicit when/when-not instructions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
imagegen_statusARead-only
Mostra backend, limites e saída; o probe opcional não gera imagem.
| Name | Required | Description | Default |
|---|---|---|---|
| run_non_consuming_probe | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool readOnlyHint=true, and the description matches by saying it 'Mostra' rather than mutates. It adds a specific behavioral reassurance that the optional probe does not generate an image, which is useful beyond the boolean parameter name. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the main purpose before adding a caveat. Every phrase earns its place and there is no redundant restatement of the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple, one-parameter, read-only tool, the description covers the operation, the main returned categories (backend, limits, output), and the key probe caveat. It is slightly vague about the shape/format of the returned output, but this is a minor gap for a status tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must carry the meaning of run_non_consuming_probe. It refers to an 'optional probe' that does not generate an image, but it doesn't explain what enabling the probe actually does or how true/false changes the status call, leaving the agent to infer the semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Mostra') and names the status resource ('backend, limites e saída'), making it clear this is a read-only status/health tool rather than an image-generation action. It further differentiates from generate_image/edit_image by stating the probe does not generate an image, though it does not explicitly distinguish from codex_account_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description conveys the tool's context as a status check and includes a useful exclusion ('o probe opcional não gera imagem'), so an agent should not use it for generation. However, it never names sibling tools or states when to choose it over codex_account_status, leaving routing mostly implicit.
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 updates
v0.1.0- First observed
codex_account_status - First observed
edit_image - First observed
generate_image - First observed
imagegen_status
TDQS
Scored across 4 tools
Each tool targets a clearly distinct action: account-level status, image generation, image editing, and backend/limits status. There is no meaningful overlap that would confuse an agent.
Names are consistently snake_case and readable, but there is a slight pattern split: generate_image and edit_image follow verb_noun, while codex_account_status and imagegen_status are noun_status. This is a minor deviation rather than a serious inconsistency.
Four tools is well-scoped for a focused Codex/imagegen integration. Each tool covers a necessary function without redundancy or bloat.
The core workflows of generating images, editing images, and checking both account and backend status are covered. Minor gaps like listing or deleting generated images exist, but they are not central to the apparent purpose.
Maintenance
Related MCP Connectors
Generate AI images and videos from any compatible MCP client.
Generate images with any major model — one API key, one prepaid balance, one MCP.
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
Generate AI images, video, music, and sound effects, and upscale them, from any MCP client.
Related MCP Servers
- AlicenseAqualityAmaintenanceGenerates and edits images via Gemini, Grok, and GPT-image providers for MCP clients like Claude Code that lack native image generation.313 npmMIT
- AlicenseAqualityCmaintenanceMCP server that connects Codex or MCP clients to MetaRouter's OpenAI-compatible image generation API, enabling natural language image generation, local image editing, batch editing, and multi-reference image synthesis.5MIT
- FlicenseNot gradedqualityCmaintenanceEnables AI image generation, editing, upload, and local download through CloseAI's gpt-image-2 service, allowing MCP-compatible clients like Codex to manage images with configurable models, sizes, and quality.-
- AlicenseNot gradedqualityAmaintenanceGenerates and edits images through the Codex CLI using an existing ChatGPT subscription, with queued jobs, progress reporting, and artifact URLs for MCP clients.538 npmMIT