Tutorial de Codex CLI MCP: crea un agente de panel de cartera

Probablemente ya te hayas dado cuenta de que los agentes de código con IA son tremendamente útiles cuando necesitas escribir funciones complejas o depurar errores difíciles. Pero a menudo se topan con un muro: dejan de ser útiles en cuanto necesitas información que no está dentro de los archivos de tu proyecto.

Ahora imagina que tu agente pudiera salir de ese entorno para traer datos en vivo, consultar documentación actualizada o usar distintas herramientas por ti. Ahí es cuando estos agentes se vuelven mucho más potentes.

En este tutorial, te mostraré paso a paso cómo conseguirlo con Codex CLI y el Model Context Protocol, o MCP. Veremos los fundamentos de cómo funcionan juntos Codex CLI y MCP, crearemos desde cero un proyecto de panel financiero con datos bursátiles en tiempo real, revisaremos patrones multiagente y hablaremos de buenas prácticas de seguridad.

Para sacarle el máximo partido, te animo a seguirlo en paralelo. Crea un proyecto nuevo de Next.js, asegúrate de tener Codex CLI instalado y en marcha, y consigue una clave de API gratuita de Alpha Vantage para ponernos manos a la obra.

Si eres nuevo en la IA agentiva, te recomiendo inscribirte en nuestro itinerario de aprendizaje AI Agent Fundamentals.

Fundamentos de Codex CLI MCP

Antes de ponernos a picar código, tenemos que entender las herramientas que vamos a usar. Desgranemos qué es exactamente MCP y cómo lo utiliza Codex CLI.

¿Qué es MCP?

MCP significa Model Context Protocol. Es un estándar abierto presentado por Anthropic para unificar cómo las IA se conectan a herramientas y fuentes de datos externas. Técnicamente, funciona mediante JSON-RPC 2.0 sobre STDIO (entrada/salida estándar) o HTTP.

Fuente: truefoundry

Esto importa porque resuelve un gran problema, lo que podríamos llamar una «pesadilla de integraciones»: antes, si querías conectar un LLM a una base de datos o herramienta concreta, solías tener que crear un conector a medida para ese par específico. Era engorroso, difícil de mantener y poco escalable.

Con MCP, ahora tenemos un protocolo único y unificado para todas las conexiones de herramientas de LLM. Simplifica el panorama sustituyendo integraciones a medida por una interfaz estándar.

Si quieres entender qué pasa bajo el capó, este tutorial para construir un servidor y cliente MCP desde cero es un buen complemento.

¿Qué es Codex CLI?

Ahora hablemos de Codex CLI. Es el agente de código de OpenAI, ligero y basado en terminal. Como otras herramientas de IA para programar, como Claude Code o Cursor, está diseñado para entender de verdad el contexto de todo tu proyecto, no solo el archivo que tienes abierto.

Lo reúne todo en un mismo sitio: combina un indexado eficiente del código, el historial de tu conversación y la ejecución real de comandos en una única interfaz de texto (TUI). Casi todo su comportamiento se puede controlar y personalizar editando un archivo config.toml, lo que facilita mucho su gestión.

Cómo implementa Codex MCP

En cuanto a la implementación de MCP, Codex admite servidores STDIO y servidores HTTP con streaming:

• STDIO: servidores que se ejecutan como procesos locales. Piensa en ellos como comandos y argumentos específicos que corren directamente en tu máquina.
• HTTP con streaming: servidores que se conectan de forma remota mediante una URL y que opcionalmente admiten autenticación con token bearer u OAuth.

Una de las funciones más cómodas es que Codex CLI y la extensión del IDE comparten el mismo archivo config.toml. Así tendrás el mismo conjunto de herramientas MCP tanto en la terminal como en el editor; no hace falta configurarlo dos veces y ahorras mucho tiempo.

Codex también gestiona bien la autenticación y admite OAuth con el comando codex mcp login <server-name>. Incluso te da control detallado sobre lo que el agente puede hacer, permitiéndote filtrar herramientas concretas con los ajustes enabled_tools o disabled_tools en tu configuración.

Configuración de Codex CLI MCP

Ya que hemos visto la teoría, toca ensuciarnos las manos y configurarlo todo. En esta sección, veremos paso a paso cómo preparar tus servidores MCP para que trabajen por ti.

Requisitos previos

Antes de conectar Codex con MCP y el Agents SDK, asegúrate de lo siguiente:

• Codex CLI está instalado en esta máquina. Puedes instalarlo globalmente ejecutando en tu terminal npm install -g @openai/codex. Verifica que todo funciona con codex --version.

• Codex está autenticado en esta máquina. Ejecuta codex login (o codex login --device-auth en entornos sin interfaz) una vez y comprueba que Codex funciona con normalidad en tu terminal.

• Para el flujo de trabajo multiagente, también necesitas una clave de API de OpenAI. Consíguela en la consola de OpenAI y configúrala en tu shell con export OPENAI_API_KEY="sk-...".

• Variables de entorno para herramientas externas configuradas. Por ejemplo, Alpha Vantage leerá tu clave de datos de mercado de ALPHA_VANTAGE_KEY, que también debes exportar antes de ejecutar los ejemplos.

Para conseguir una clave de API de AlphaVantage:

1. Ve a la página de soporte de AlphaVantage.
2. Rellena el breve formulario de registro (organización, rol y correo electrónico).
3. Verás tu clave de API al instante. Cópiala y guárdala de forma segura.

El plan gratuito permite hasta 25 solicitudes de API al día. Para un uso más intensivo, Alpha Vantage ofrece planes premium.

Añadir servidores MCP desde la CLI

A continuación, añadiremos un servidor con la interfaz de línea de comandos usando codex mcp add. Así no tienes que tocar los archivos de configuración a mano y Codex hace la mayor parte del trabajo por ti.

Por ejemplo, si quieres añadir un servidor para consultar documentación, puedes usar el servidor MCP de Context7. Para instalarlo, ejecuta en tu terminal:

codex mcp add context7 -- npx -y @upstash/context7-mcp

Añadir servidores MCP mediante config.toml

Aunque los comandos de la CLI son ideales para empezar rápido, a veces necesitas más control o prefieres ver exactamente qué sucede por debajo. En ese caso, puedes editar el archivo de configuración directamente.

Es importante saber que hay dos ubicaciones para esta configuración y su alcance difiere:

• Archivo de configuración global en ~/.codex/config.toml, que se aplica a todos tus proyectos

• Archivo de configuración por proyecto en .codex/config.toml dentro de la carpeta de tu proyecto. Normalmente, la configuración del proyecto sobrescribe la global si hay conflicto.

No todos los servidores MCP incluyen un comando de instalación por CLI. En esos casos, los configuras directamente en ~/.codex/config.toml indicando el comando y los argumentos que necesita Codex para lanzar el proceso del servidor. Esto te da control total sobre cómo se inicia, ya sea localmente por STDIO o conectando de forma remota por HTTP.

El servidor MCP de AlphaVantage es uno de ellos. Abre config.toml y añade el siguiente bloque:

[mcp_servers.alphavantage]
command = "uvx"
args = ["av-mcp", "<your-key>”]

Aviso: incrustar una clave de API directamente en config.toml no es una práctica recomendada en proyectos reales. Evítalo en cualquier proyecto con control de versiones (por ejemplo, en GitHub), compartido con otros desarrolladores o desplegado en un servidor, ya que cualquiera con acceso al archivo podría leer y usar tu clave indebidamente. Para este tutorial, es aceptable porque config.toml vive en tu directorio personal (~/.codex/) y es solo para tu máquina.

Es útil añadir startup_timeout_sec=30 para ampliar el tiempo de espera por defecto (10 segundos) y dar margen a que la conexión se establezca.

Gestionar servidores MCP

Una vez que tengas varios servidores configurados, necesitarás saber cómo gestionarlos. Codex te ofrece una serie de comandos para mantener todo organizado.

Para ver qué hay instalado, ejecuta codex mcp list. Si quieres ver los detalles de un servidor, como el de Alpha Vantage que acabamos de añadir, usa codex mcp get alphavantage. Y si decides que ya no necesitas un servidor, por ejemplo Context7, elimínalo con codex mcp remove context7.

Por último, cuando trabajes dentro de una sesión activa de Codex, puedes comprobar que todo funciona. Escribe /mcp directamente en la interfaz de chat y verás el estado de tus herramientas conectadas. Deberían aparecer alphavantage y context7, cada una con Status: enabled.

Crear un panel de riesgo de cartera con Codex y MCP

La teoría está bien, pero la mejor forma de aprender es construyendo algo real. En esta sección, crearemos un panel funcional de riesgo de cartera desde cero usando Codex y MCP para obtener datos de mercado reales y calcular métricas de riesgo.

Para mostrar el panel, el proyecto usa TypeScript, un lenguaje basado en JavaScript. Si necesitas un repaso, te recomiendo nuestra guía de preguntas de entrevista sobre TypeScript.

Configurar el proyecto

Sigue estos pasos para configurar el proyecto:

1. Inicializa el proyecto: ejecuta en tu terminal el comando estándar de creación de Next.js: npx create-next-app@latest portfolio-dashboard --typescript

2. Acepta las opciones por defecto para asegurar una configuración estándar

3. Ve al directorio de tu nuevo proyecto: cd portfolio-dashboard

4. Prepara la estructura de componentes creando un subdirectorio para tu UI: mkdir components

5. Crea el elemento de tarjeta de cartera como archivo .tsx en la subcarpeta components: components/PortfolioCard.tsx

El componente define un PortfolioCard que renderiza una tarjeta con estilo mostrando una lista de posiciones simuladas (AAPL y TSLA), con el símbolo de cada acción, número de participaciones y precio actual. Usa clases de Tailwind CSS para disposición y estilo, con un contenedor blanco y formato de precio en verde esmeralda. Debería verse así:

// components/PortfolioCard.tsx
import React from 'react';

type Position = {
  symbol: string;
  shares: number;
  price: number;
};

const mockPositions: Position[] = [
  { symbol: 'AAPL', shares: 10, price: 150.00 },
  { symbol: 'TSLA', shares: 5, price: 900.00 },
];

export const PortfolioCard = () => {
  return (
    // Added text-slate-900 to ensure visibility on the white background
    <div className="p-6 border border-slate-200 rounded-xl shadow-sm bg-white text-slate-900">
      <h2 className="text-xl font-bold mb-4">My Portfolio</h2>
      <ul className="divide-y divide-slate-100">
        {mockPositions.map((pos) => (
          <li key={pos.symbol} className="flex justify-between py-3">
            <div className="flex flex-col">
              <span className="font-bold text-slate-800">{pos.symbol}</span>
              <span className="text-sm text-slate-500">{pos.shares} shares</span>
            </div>
            <span className="font-mono font-semibold text-emerald-600">
              ${pos.price.toFixed(2)}
            </span>
          </li>
        ))}
      </ul>
    </div>
  );
};

Después de guardar el archivo, asegúrate de importar y usar <PortfolioCard/> dentro de tu archivo principal app/page.tsx para verlo en el navegador:

// app/page.tsx
import { PortfolioCard } from "../components/PortfolioCard";

export default function Page() {
  return (
    <main className="min-h-screen flex items-center justify-center bg-slate-50">
      <PortfolioCard />
    </main>
  );
}

Cuando ejecutes npm run dev, deberías ver algo así en el navegador:

Antes de empezar a programar con IA, asegúrate de que los agentes estén activos. Deja la terminal corriendo con npm run dev. En una nueva ventana de terminal:

1. Ejecuta los comandos de configuración de MCP que comentamos antes, si aún no lo hiciste

2. Exporta tu clave de API con ALPHA_VANTAGE_KEY=”<your-key>”

3. En la misma ventana, inicia el agente de Codex ejecutando codex

Implementar la función de ratio de Sharpe

La primera funcionalidad que calcularemos es el ratio de Sharpe, una métrica clave para evaluar la rentabilidad ajustada al riesgo de una inversión. Buscar la fórmula y la librería adecuada puede ser tedioso. Deja que Codex se encargue.

En tu sesión de Codex en la terminal, escribe este prompt:

"Add Sharpe ratio calculation for each position to PortfolioCard.tsx. Use Context7 to check the function signature if needed."

Verás a Codex en acción. Primero puede usar la herramienta Context7 para consultar la documentación de la librería de análisis técnico (ta-lib o un equivalente en JavaScript) y confirmar los parámetros correctos. Luego modificará automáticamente tu archivo PortfolioCard.tsx.

Es probable que amplíe mockPositions y añada una función auxiliar para calcular el ratio similar a esto:

function calculateSharpe(prices: number[]) {
  // Codex implements the logic here using standard deviation and mean returns
  // resulting in a return value like 1.23
}

Y actualizará tu JSX para mostrar la nueva métrica:

<PortfolioCard sharpe={calculateSharpe(prices)}/>

Al comprobar el navegador, ahora deberías ver el ratio de Sharpe (por ejemplo, 1,23) junto a tus posiciones, como aquí:

Añadir alertas de volatilidad

Ahora hagamos el panel reactivo y usemos datos reales de AlphaVantage. Queremos que nos avise si una acción se vuelve demasiado volátil. Definiremos «alta volatilidad» como una volatilidad a 7 días superior al 3%.

En la terminal de Codex, introduce este prompt:

"Flag positions where 7-day volatility > 2% using Alpha Vantage data. Fetch the price history for the symbols in my list."

Aquí es donde MCP brilla. Codex reconocerá que necesita datos externos. Llamará a alphavantage.get_price_history("AAPL") y alphavantage.get_price_history("TSLA") para obtener datos reales.

Una vez tenga los datos, escribirá la lógica para calcular la desviación estándar de esos precios. Por último, actualizará el estilo de tu componente para señalar visualmente el riesgo.

Verás que el código de PortfolioCard se actualiza con estilos condicionales. La lógica podría ser así:

<li className={volatility > 2 ? "text-red-500 font-bold" : "text-green-500"}>
  {pos.symbol}: {volatility}%
</li>

Si miras tu aplicación en ejecución, puede que veas AAPL en verde (segura) y TSLA en rojo (volátil), todo basado en datos de mercado en vivo obtenidos por el agente.

El resultado final debería parecerse a esto:

Tu UI final puede diferir un poco de la imagen según cómo lo estructure Codex. Por supuesto, también puedes afinar tu prompt y decirle a Codex exactamente cómo quieres el resultado.

Si quieres diseñar sistemas más grandes y aprender sobre handoffs, límites de herramientas y evaluación, te recomiendo el curso Building Scalable Agentic Systems.

Ejecutar Codex como servidor MCP

Hasta ahora, hemos usado Codex como la interfaz principal que llama a otras herramientas. Pero aquí viene lo interesante: Codex también puede actuar como servidor MCP.

Esto significa que puedes exponer las potentes capacidades de edición de archivos y ejecución de comandos de Codex a otros clientes MCP, permitiendo que otros agentes de IA usen Codex como herramienta en sus propios flujos. La gran ventaja es que habilita la ejecución en paralelo.

Puedes diseñar un flujo en el que un agente use Codex para crear tu frontend mientras otro agente, en una instancia distinta de Codex, escribe tu API backend. Como se ejecutan en procesos separados, pueden trabajar simultáneamente y reducir a la mitad el tiempo de desarrollo.

Iniciar el modo servidor de Codex

Para poner Codex en este modo, usamos un comando específico: codex mcp-server.

Al ejecutarlo, Codex deja de comportarse como una interfaz de chat y pasa a escuchar instrucciones de otro programa. Expone sus capacidades a través del canal de entrada/salida estándar (STDIO).

Antes de integrarlo en un sistema complejo, conviene probar que funciona. El equipo de Model Context Protocol proporciona una herramienta de inspección muy útil. Ejecuta este comando para abrir una interfaz web que se conecta a tu instancia local de Codex:

npx @modelcontextprotocol/inspector codex mcp-server

Se abrirá una ventana del navegador donde podrás enviar comandos manualmente a Codex y ver cómo responde, lo que ayuda mucho a depurar. La UI se ve así:

Integración con OpenAI Agents SDK

Si programas en Python, quizá quieras orquestar Codex dentro de un script usando OpenAI Agents SDK. Esto te permite crear un programa en Python que pueda «contratar» a Codex para tareas de desarrollo concretas.

Aquí tienes un ejemplo rápido de cómo configurarlo. Usas MCPServerStdio para lanzar el proceso de Codex:

En tu entorno virtual de Python, instala el paquete openai-agents:

pip install openai-agents

Para configurar el proceso de Codex, crea un archivo orchestrator.py con el siguiente código:

from agents import Agent
from agents.mcp import MCPServerStdio

# initialize connection
codex_server = MCPServerStdio(
    name="Codex CLI",
    params={
        "command": "npx",
        "args": ["-y", "codex", "mcp-server"]
    },
    client_session_timeout_seconds=360000,
)
# create codex agent
agent = Agent(
    name="Lead Developer",
    mcp_servers=[codex_server]
)

En esta configuración, el servidor MCP de Codex expone dos herramientas principales: codex() y codex-reply(). Es importante entender la diferencia para que el agente conserve el contexto de lo que está haciendo.

• Usa codex() cuando quieras iniciar una sesión o tarea nueva.
• Usa codex-reply() cuando quieras continuar una conversación existente o iterar sobre el trabajo que acaba de hacerse. Requiere un parámetro conversationId para mapear la solicitud a la conversación correcta.

El parámetro client_session_timeout_sessions marca el tiempo máximo que el cliente mantiene abierta una sesión con el servidor MCP por STDIO. Lo dejamos muy generoso en 360.000 segundos (100 horas) para Codex, de modo que los flujos largos puedan reutilizar la misma sesión MCP sin cortes por inactividad.

Wrappers de la comunidad

La comunidad también ha creado wrappers que lo simplifican aún más. Un proyecto destacable es el repositorio codex-mcp-wrapper en GitHub. Este wrapper está pensado para integrar Codex en otros entornos, como Claude Code.

Orquestar un pipeline financiero multiagente con Codex CLI MCP

Ahora que sabemos ejecutar Codex como servidor, veamos un caso real donde esto cobra fuerza. Vamos a orquestar un pipeline multiagente en el que varios agentes de IA colaboran para acelerar notablemente la mejora de nuestro panel financiero frente a un agente único.

Si el diseño multiagente te parece abstracto, aquí tienes un resumen claro de arquitecturas de agentes y cuándo realmente ayudan los enfoques multiagente.

Coordinar los agentes de riesgo y de UI

En este montaje, usamos un script en Python como orquestador del flujo. En lugar de pedir a un único agente que lo haga todo, lanzamos dos agentes especializados:

• Codex-Risk, centrado en análisis cuantitativo
• Codex-UI, centrado en la implementación del frontend

Dado que ahora ejecutamos Codex como servidor MCP sin interfaz desde el Agents SDK, tanto el SDK como los procesos de Codex deben autenticarse en OpenAI, no solo la CLI interactiva de Codex.

Para simplificar y hacerlo fiable, asegúrate de que OPENAI_API_KEY (o, opcionalmente, CODEX_API_KEY) está configurada en tu entorno antes de ejecutar el orquestador para que todas las piezas puedan hablar con los modelos. Ejecuta este comando en una nueva terminal:

export OPENAI_API_KEY=<your-key>

Inicializamos dos servidores MCP de Codex independientes dentro de un bloque async with para asegurar conexiones estables y aisladas (un proceso por agente), que es lo que les permite ejecutarse en paralelo. Este es el script de orquestación, orchestrator.py:

import os
import asyncio
from dotenv import load_dotenv
from agents import Agent, Runner
from agents.mcp import MCPServerStdio


load_dotenv()


async def main():
    async with MCPServerStdio(
        name="Codex-Risk-Server",
        params={
            "command": "npx",
            "args": ["-y", "codex", "mcp-server"],
            # Codex itself uses your existing auth (codex login / OPENAI_API_KEY)
            "env": {
                # pass through any env you already rely on inside Codex
                "OPENAI_API_KEY": os.getenv("OPENAI_API_KEY", ""),
                "CODEX_API_KEY": os.getenv("CODEX_API_KEY", ""),
            },
        },
        client_session_timeout_seconds=360000,
    ) as codex_risk_server, MCPServerStdio(
        name="Codex-UI-Server",
        params={
            "command": "npx",
            "args": ["-y", "codex", "mcp-server"],
            "env": {
                "OPENAI_API_KEY": os.getenv("OPENAI_API_KEY", ""),
                "CODEX_API_KEY": os.getenv("CODEX_API_KEY", ""),
            },
        },
        client_session_timeout_seconds=360000,
    ) as codex_ui_server:

        # 1. Define specialized agents (both just use the 'codex' tool)
        risk_agent = Agent(
            name="Codex-Risk",
            instructions=(
                "You are a quant analyst. Use the 'codex' tool to compute VaR and "
                "Sharpe ratio for all positions in the portfolio-dashboard project. "
                "Assume Alpha Vantage integration and volatility logic are already implemented "
                "in the code; reuse and extend that code instead of re-calling external APIs."
            ),
            mcp_servers=[codex_risk_server],
        )

        ui_agent = Agent(
            name="Codex-UI",
            instructions=(
                "You are a frontend developer. Use the 'codex' tool to update the UI in "
                "the portfolio-dashboard project. Your job is to add a VaR (95%) column "
                "to the RiskTable / PortfolioCard views, with clear red/green conditional styling."
            ),
            mcp_servers=[codex_ui_server],
        )

        # 2. Run Risk + UI agents concurrently
        risk_task = Runner.run(
            risk_agent,
            "Compute portfolio VaR (95%) for all positions and write the results into the codebase "
            "in a way that the UI can easily consume (e.g., exported constants or helper functions).",
        )
        ui_task = Runner.run(
            ui_agent,
            "Prepare or update the RiskTable / PortfolioCard components to display a VaR (95%) "
            "column, assuming the risk logic already exists in the project.",
        )

        risk_result, ui_result = await asyncio.gather(risk_task, ui_task)

        print("=== Codex-Risk result ===")
        print(risk_result.final_output)
        print("\n=== Codex-UI result ===")
        print(ui_result.final_output)

        # 3. Optional second pass: let UI agent consume the exact risk output
        followup_ui_result = await Runner.run(
            ui_agent,
            (
                "Now update the UI to wire in the actual VaR values. "
                f"Context from the risk agent: {risk_result.final_output}"
            ),
        )

        print("\n=== Codex-UI follow-up ===")
        print(followup_ui_result.final_output)


if __name__ == "__main__":
    asyncio.run(main())

En la misma terminal en la que configuraste tu clave de OpenAI, ejecuta el script de orquestación:

python orchestrator.py

Estos agentes trabajarán de forma independiente: consultarán la documentación de Alpha Vantage mediante MCP, obtendrán los datos históricos y escribirán la lógica en Python o TypeScript para calcular el Valor en Riesgo (VaR) de tu cartera.

Una vez que las dos instancias de Codex hagan los cambios, puedes visualizarlos ejecutando de nuevo npm run dev para ver el resultado final en el navegador. Se parecerá a esto:

Al separar responsabilidades, convertimos un proceso que normalmente llevaría 20 minutos de idas y venidas en un pipeline totalmente automatizado. El agente de riesgo se ocupa de las métricas y el agente de UI de la implementación; el panel se actualiza en segundos.

Ejecución paralela de tareas

La verdadera magia está en el modelo de ejecución. En una interfaz de chat estándar, las llamadas a herramientas son secuenciales: tienes que esperar a que lleguen los datos antes de pedir que se actualice la gráfica.

Con MCP y este enfoque multiagente, logramos concurrencia real. Mientras el agente Codex-Risk espera respuestas de red del API de Alpha Vantage, el agente Codex-UI ya puede estar montando las columnas de la tabla y configurando las clases CSS.

Al separar estas tareas, pasas de un proceso de 15 o 20 minutos a una cadena optimizada. De la obtención de datos en bruto al análisis de riesgo y a funciones de UI completamente implementadas en unos 5 minutos.

Consideraciones de seguridad y limitaciones

Como con cualquier herramienta potente que conecta tu código con el exterior, hay que hablar de seguridad. Aunque Codex y MCP desbloquean capacidades increíbles, también introducen nuevas superficies de ataque y limitaciones prácticas que debes conocer antes de usarlos en producción.

Vulnerabilidades de configuración

El aspecto más crítico es el archivo de configuración. En versiones anteriores de Codex CLI hubo una vulnerabilidad conocida por la que se podían inyectar comandos maliciosos a través de config.toml en combinación con un archivo .env que redirigía CODEX_HOME a un directorio local. Esto ya está parcheado, así que es clave asegurarte de estar usando la versión v0.23.0 o superior.

Sin embargo, el riesgo no desaparece del todo con actualizaciones. Como Codex respeta configuraciones por proyecto, si clonas un repositorio que incluye un .codex/config.toml malicioso junto con un .env que define CODEX_HOME=./.codex, ejecutar codex dentro de esa carpeta podría ejecutar comandos inesperados definidos ahí.

Acostúmbrate a auditar el archivo de configuración de cualquier proyecto nuevo que clones. Trátalo con máxima cautela antes de ejecutar nada.

Limitaciones de MCP

En la práctica, hay algunos flecos. Actualmente no hay una «prueba de conectividad» integrada al lanzar la CLI. Codex no te avisará automáticamente si un servidor MCP está caído o no accesible al inicio. Básicamente tienes que pedirle algo como «Check my tools» para que verifique la conexión.

Además, aunque sea tentador instalar todas las herramientas disponibles, hay que ser selectivo. Si conectas demasiados servidores MCP, el rendimiento del modelo empieza a degradarse notablemente. Cuantas más herramientas añadas, más «ruido» tendrá que filtrar el modelo, lo que puede confundirlo o provocar alucinaciones. Es buena práctica adjuntar solo los MCP que necesites.

Codex CLI vs Claude Code

Por último, vale la pena comparar Codex CLI con su competidor directo, Claude Code.

Si tu objetivo es la automatización y las pipelines de integración continua (CI), Codex CLI suele ser la mejor opción. Es ligero, fácil de usar y altamente scriptable. Claude Code, por su parte, brilla como entorno de programación interactiva dentro del editor, con una UX muy cuidada para refactors, ejecución de tests y asistentes por proyecto.

También difiere el estilo de configuración. Codex se apoya en archivos TOML, con un ~/.codex/config.toml compartido entre la CLI y la extensión del IDE, además de posibles overrides por proyecto en .codex/config.toml dentro de cada repo. Esto implica que tu entorno se comparte por defecto, pero puede personalizarse por proyecto.

Claude Code suele usar ajustes basados en JSON, con una configuración global (por ejemplo, ~/.claude.json) y archivos por proyecto (como .mcp.json o ajustes del proyecto) que permiten a cada repositorio definir sus propios servidores MCP y comportamiento, lo que mejora el aislamiento a costa de algo más de configuración por repo.

Aunque ambas herramientas representan la vanguardia de los agentes de código con IA, la elección depende de tu flujo de trabajo: si piensas en el agente como algo que vive principalmente en la terminal o en trabajos de CI, Codex suele encajar mejor; si buscas sobre todo un compañero de programación centrado en el editor, Claude Code suele resultar más natural.

Para profundizar en esta comparación, te recomendamos leer nuestra guía Codex vs Claude Code.

Conclusión

Hoy hemos cubierto mucho: desde las definiciones básicas de MCP hasta la creación de nuestro propio agente con Codex. Pero si te quedas con una sola idea, que sea el poder del flujo de trabajo en sí. Configurar tu servidor MCP, ejecutar Codex y ver cómo las herramientas descubren automáticamente los datos que necesitan te permite crear funcionalidades más rápido que cualquier humano.

Si acabas de empezar, no lo compliques. Empieza con Context7 para documentación y quizá un solo MCP basado en API, como el de Alpha Vantage que montamos hoy. Familiarízate con ese flujo antes de probar con múltiples agentes.

Una vez cojas confianza, el límite lo pones tú. Prueba otros MCP. Conecta Figma para generar código de UI a partir de diseños o integra Sentry para que Codex diagnostique y corrija automáticamente errores en producción. Experimenta con subagentes de Codex y descubre cuánto trabajo rutinario puedes delegar. Las herramientas están aquí, son potentes y están listas para que las uses.

Si te interesa desarrollar aplicaciones de IA, te recomiendo inscribirte en nuestro itinerario de aprendizaje AI Engineering with LangChain. El contenido es AI-native: tendrás un tutor personal que te enseñará exactamente lo que necesitas desde tu nivel para dominar la ingeniería de flujos de trabajo con IA.