Codex CLI MCP-tutorial: een portfoliodashboard-agent bouwen

Je hebt vast al gemerkt dat AI-codeagents ongelooflijk handig zijn als je complexe functies moet schrijven of lastige bugs wilt oplossen. Maar vaak lopen ze vast. Ze houden meestal op met nuttig zijn zodra je informatie nodig hebt die niet al in je projectbestanden staat.

Stel je nu voor dat je codeagent buiten die omgeving kan reiken om live data op te halen, actuele documentatie op te zoeken of namens jou verschillende tools te gebruiken. Dán worden deze agents een stuk krachtiger.

In deze tutorial laat ik je stap voor stap zien hoe je dat bereikt met de Codex CLI en het Model Context Protocol, oftewel MCP. We behandelen de basis van hoe Codex CLI en MCP samenwerken, we bouwen vanaf nul een finance-dash­board met live koersdata, we bespreken patronen voor multi-agents en we nemen de beste beveiligingspraktijken door.

Om hier echt het meeste uit te halen, raad ik je aan om mee te bouwen. Maak een nieuw Next.js-project, controleer of je een werkende installatie van de Codex CLI hebt, en haal een gratis API-sleutel bij Alpha Vantage zodat we meteen aan de slag kunnen.

Ben je nieuw met agentische AI, schrijf je dan zeker in voor onze skill track AI Agent Fundamentals.

Codex CLI MCP: de basis

Voordat we gaan coderen, moeten we de tools begrijpen die we gebruiken. Laten we precies uitleggen wat MCP is en hoe de Codex CLI het benut.

Wat is MCP?

Wat is MCP? Het staat voor het Model Context Protocol. Het is een open standaard, geïntroduceerd door Anthropic, om te standaardiseren hoe AI-systemen verbinden met externe tools en databronnen. Technisch draait het via JSON-RPC 2.0 over STDIO (standaardinvoer/-uitvoer) of HTTP.

Bron: truefoundry

Waarom is dit belangrijk? Het lost een groot probleem op, wat je een “integratie-nightmare” kunt noemen: vroeger moest je voor elke koppeling tussen een LLM en een specifieke database of tool vaak een custom connector bouwen. Dat was rommelig, lastig te onderhouden en slecht schaalbaar.

Met MCP is er nu één uniform protocol voor alle LLM-toolkoppelingen. Het vereenvoudigt het landschap door maatwerkintegraties te vervangen door een standaardinterface.

Wil je onder de motorkap kijken, dan is deze walkthrough voor het bouwen van een MCP-server en -client vanaf nul een goede aanvulling.

Wat is Codex CLI?

Dan nu de Codex CLI. Dit is OpenAI’s lichte, terminalgebaseerde codeagent. Net als andere AI-codetools, zoals Claude Code of Cursor, is het gemaakt om je hele projectcontext te begrijpen, niet alleen het bestand dat je nu open hebt.

Alles komt samen op één plek: efficiënte code-indexering, je gespreksgeschiedenis en het daadwerkelijk uitvoeren van commando’s in een enkele Text User Interface (TUI). Bijna al het gedrag is te sturen en aan te passen via een config.toml-bestand, wat het beheer eenvoudig maakt.

Hoe Codex MCP implementeert

Qua MCP-implementatie ondersteunt Codex zowel STDIO-servers als Streamable HTTP-servers:

• STDIO-servers draaien als lokale processen. Zie ze als specifieke commando’s en argumenten die rechtstreeks op je machine draaien.
• Streamable HTTP-servers verbinden op afstand via een URL en ondersteunen optioneel een bearer token of OAuth-authenticatie.

Handig is dat de Codex CLI en de IDE-extensie hetzelfde config.toml-bestand delen. Zo heb je consistente MCP-tools, of je nu in de terminal werkt of in je editor; je hoeft het niet twee keer te configureren, wat veel tijd scheelt.

Codex regelt authenticatie ook prima, met ondersteuning voor OAuth via het commando codex mcp login <server-name>. Je kunt zelfs fijnmazig bepalen wat de agent mag doen door specifieke tools te filteren met de instellingen enabled_tools of disabled_tools in je configuratie.

Codex CLI MCP instellen

Nu de theorie behandeld is, gaan we aan de slag. In dit deel laten we zien hoe je MCP-servers zo configureert dat ze voor je klaarstaan.

Vereisten

Voordat je Codex koppelt aan MCP en de Agents SDK, zorg dat het volgende geregeld is:

• De Codex CLI is op deze machine geïnstalleerd. Je kunt ’m globaal installeren door in je terminal npm install -g @openai/codex uit te voeren. Controleer de installatie met codex --version.

• Codex is geauthenticeerd op deze machine. Voer eenmalig codex login (of codex login --device-auth in headless-omgevingen) uit en controleer dat Codex normaal werkt in je terminal.

• Voor de multi-agentworkflow heb je ook een OpenAI API-sleutel nodig. Haal die op in de OpenAI-console en stel ’m in je shell in met export OPENAI_API_KEY="sk-...".

• Omgevingsvariabelen voor externe tools zijn ingesteld. Alpha Vantage leest je marktdataskey bijvoorbeeld uit ALPHA_VANTAGE_KEY, die je op dezelfde manier moet exporteren voordat je de voorbeelden draait.

Zo krijg je een AlphaVantage API-sleutel:

1. Ga naar de AlphaVantage-supportpagina.
2. Vul het korte registratieformulier in (organisatie, rol en e-mail).
3. Je API-sleutel verschijnt direct. Kopieer ’m en bewaar ’m veilig.

De gratis laag staat tot 25 API-requests per dag toe. Voor zwaarder gebruik biedt Alpha Vantage premiumplannen.

MCP-servers toevoegen via de CLI

Vervolgens voegen we een nieuwe server toe via de command line met het commando codex mcp add. Zo hoef je niet handmatig met configuratiebestanden te rommelen en doet Codex het meeste werk voor je.

Wil je bijvoorbeeld een server toevoegen voor documentatie-opzoekingen, dan kun je de Context7 MCP-server gebruiken. Installeer ’m met dit commando in je terminal:

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

MCP-servers toevoegen via config.toml

Hoewel CLI-commando’s ideaal zijn om snel te starten, heb je soms meer controle nodig of wil je precies zien wat er gebeurt. In dat geval kun je het configuratiebestand direct bewerken.

Belangrijk om te weten: de configuratie staat op twee plaatsen, met een verschillend bereik:

• Globaal configuratiebestand op ~/.codex/config.toml, van toepassing op elk project

• Projectspecifiek configuratiebestand op .codex/config.toml in je projectmap. Meestal overschrijven projectspecifieke instellingen globale instellingen bij conflicten.

Niet alle MCP-servers worden geleverd met een eigen CLI-installcommando. In die gevallen configureer je ze direct in ~/.codex/config.toml door het commando en de argumenten op te geven die Codex nodig heeft om het serverproces te starten. Zo bepaal je volledig hoe de server start, lokaal via STDIO of extern via HTTP.

De AlphaVantage MCP-server is er zo eentje. Open config.toml en voeg het volgende blok toe:

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

Disclaimer: een API-sleutel hardcoden in config.toml is geen aanbevolen praktijk voor echte projecten. Vermijd dit in projecten die onder versiebeheer staan (bijv. op GitHub), gedeeld worden met andere ontwikkelaars of op een server draaien, omdat iedereen met toegang tot het bestand je key kan lezen en misbruiken. Voor deze tutorial kan het, omdat config.toml in je homedirectory (~/.codex/) staat en persoonlijk is voor jouw machine.

Een nuttige regel om toe te voegen is startup_timeout_sec=30 om de standaardtime-out van 10 seconden te verhogen, zodat de verbinding genoeg tijd krijgt om tot stand te komen.

MCP-servers beheren

Zodra je een paar servers hebt ingesteld, wil je weten hoe je ze beheert. Codex biedt een reeks commando’s om alles overzichtelijk te houden.

Wil je zien wat er nu is geïnstalleerd, voer dan codex mcp list uit. Wil je de details van een server controleren, zoals die van Alpha Vantage die we zojuist hebben toegevoegd, voer dan codex mcp get alphavantage uit. En als je besluit dat je een server niet meer nodig hebt, bijvoorbeeld de Context7-server, dan verwijder je die met codex mcp remove context7.

Tot slot kun je in een actieve Codex-sessie verifiëren dat alles goed draait. Typ /mcp in de chatinterface en je ziet de status van je gekoppelde tools. Je zou zowel alphavantage als context7 moeten zien, elk met Status: enabled.

Een stockportefeuille-risicodashboard bouwen met Codex en MCP

Theorie is nuttig, maar het beste leer je door iets echts te bouwen. In dit deel maken we een functioneel risicodashboard voor een aandelenportefeuille, met Codex en MCP om echte marktdata op te halen en risicometrics te berekenen.

Voor het dashboard gebruiken we TypeScript, een op JavaScript gebaseerde programmeertaal. Voor een opfrisser op verschillende niveaus raad ik onze gids met TypeScript-sollicitatievragen aan.

Het project opzetten

Volg deze stappen om het project op te zetten:

1. Initialiseer het project: voer in je terminal het standaard Next.js-commando uit: npx create-next-app@latest portfolio-dashboard --typescript

2. Accepteer de standaardprompts voor een standaardconfiguratie

3. Navigeer naar de map van je nieuwe project: cd portfolio-dashboard

4. Bereid de componentstructuur voor door een submap te maken voor je UI-componenten: mkdir components

5. Maak het portfoliokaart-element als .tsx-bestand in de submap components: components/PortfolioCard.tsx

De component definieert een PortfolioCard die een gestylede kaart rendert met een lijst van mock-positie’s (AAPL en TSLA) met per aandeel het symbool, aantal aandelen en huidige prijs. Hij gebruikt Tailwind CSS-klassen voor layout en styling, met een witte kaartcontainer en smaragdgroene prijsopmaak. Het zou er zo uit moeten zien:

// 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>
  );
};

Sla dit bestand op en importeer en gebruik <PortfolioCard/> in je hoofdbestand app/page.tsx zodat je het in de browser kunt zien:

// 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>
  );
}

Als je nu npm run dev draait, zou je in je browser ongeveer dit moeten zien:

Voordat we met AI gaan coderen, moeten we zorgen dat onze agents actief zijn. Laat de terminal met npm run dev draaien. Open in een nieuw terminalvenster:

1. Voer de MCP-configuratiecommando’s uit die we eerder bespraken, als je dat nog niet hebt gedaan

2. Exporteer je API-sleutel via export ALPHA_VANTAGE_KEY=”<your-key>”

3. Start in hetzelfde terminalvenster de Codex-agent met codex

Een Sharpe-ratiofunctie implementeren

De eerste feature die we berekenen is de Sharpe-ratio, een cruciale maat om het risico-gecorrigeerde rendement te beoordelen. Normaal is de formule opzoeken en de juiste library vinden wat omslachtig. Dat laten we Codex doen.

Typ in je Codex-terminal de volgende prompt:

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

Je ziet Codex aan het werk gaan. Eerst kan het de Context7-tool gebruiken om documentatie over de technische-analysebibliotheek (ta-lib of een JavaScript-equivalent) op te zoeken om de juiste inputs te verzekeren. Vervolgens past het automatisch je PortfolioCard.tsx-bestand aan.

Waarschijnlijk breidt het mockPositions uit en voegt het een helperfunctie toe om de ratio te berekenen, die er ongeveer zo uitziet:

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

En het werkt je JSX bij om de nieuwe metric te renderen:

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

Als je je browser controleert, zie je nu een Sharpe-ratio (bijv. 1,23) naast je posities, zoals hier:

Volatiliteitsalerts toevoegen

Laten we het dashboard nu reactief maken en echte financiële data van AlphaVantage gebruiken. We willen een alert als een aandeel te volatiel wordt. We definiëren “hoge volatiliteit” als een 7-daagse volatiliteit groter dan 3%.

Voer in de Codex-terminal deze prompt in:

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

Hier blinkt MCP uit. Codex herkent dat er externe data nodig is. Het zal alphavantage.get_price_history("AAPL") en alphavantage.get_price_history("TSLA") aanroepen om echte datapunten op te halen.

Na het ophalen van de data schrijft het de logica om de standaardafwijking van die prijzen te berekenen. Tot slot werkt het de styling van je component bij om het risico visueel te markeren.

Je ziet dat je PortfolioCard-code voorwaardelijke styling krijgt. De logica kan er zo uitzien:

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

In je draaiende app zie je mogelijk AAPL in groen (veilig) en TSLA in rood (volatiel), allemaal gebaseerd op live marktdata die de agent heeft opgehaald.

Het eindresultaat zou er ongeveer zo uit moeten zien:

Je uiteindelijke UI kan iets afwijken van de afbeelding hierboven, afhankelijk van hoe Codex het structureert. Je kunt uiteraard ook preciezer zijn in je prompt en Codex vertellen hoe het eindresultaat eruit moet zien.

Wil je grotere systemen ontwerpen en leren over handoffs, toolgrenzen en evaluatie, volg dan onze cursus Building Scalable Agentic Systems.

Codex draaien als een MCP-server

Tot nu toe gebruikten we Codex als de hoofdinterface die andere tools aanroept. Maar nu wordt het interessant: Codex kan zelf ook als MCP-server fungeren.

Dat betekent dat je Codex’ krachtige bestandsbewerking en commando-uitvoering kunt blootstellen aan andere MCP-clients, zodat andere AI-agents Codex als tool in hun workflows kunnen gebruiken. Het grootste voordeel is dat dit parallelle uitvoering mogelijk maakt.

Je kunt een workflow ontwerpen waarin één agent Codex gebruikt om je frontend-UI te bouwen, terwijl een andere agent een aparte Codex-instantie gebruikt om je backend-API te schrijven. Omdat ze als aparte processen draaien, kunnen ze gelijktijdig werken en zo je ontwikkeltijd potentieel halveren.

Codex in servermodus starten

Om Codex in deze modus te zetten, gebruiken we een specifiek commando: codex mcp-server.

Als je dit draait, stopt Codex met zich te gedragen als een chatinterface en begint het te luisteren naar instructies van een ander programma. Het stelt zijn mogelijkheden beschikbaar via het STDIO-kanaal (standaardinvoer/-uitvoer).

Voordat je dit in een complex systeem integreert, is het verstandig om te testen of het werkt. Het Model Context Protocol-team levert hiervoor een handige inspector. Met het volgende commando start je een webinterface die verbinding maakt met je lokale Codex-instantie:

npx @modelcontextprotocol/inspector codex mcp-server

Er opent een browservenster waarin je handmatig commando’s naar Codex kunt sturen en precies ziet hoe het reageert—erg handig om te debuggen. De UI ziet er zo uit:

OpenAI Agents SDK-integratie

Ben je Python-developer, dan wil je Codex misschien orkestreren in een eigen script met de OpenAI Agents SDK. Zo kun je een Pythonprogramma bouwen dat Codex “inhuurt” voor specifieke codetaken.

Hier is een snel voorbeeld van de setup. Je gebruikt MCPServerStdio om het Codex-proces te starten:

Installeer in je Python-virtualenv het pakket openai-agents:

pip install openai-agents

Maak voor de codex-setup een bestand orchestrator.py met deze code:

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]
)

In deze setup stelt de Codex MCP-server twee hoofdtools beschikbaar: codex() en codex-reply(). Het is belangrijk het verschil te begrijpen, omdat dat ervoor zorgt dat de agent de context behoudt van waar hij aan werkt.

• Gebruik codex() als je een gloednieuwe sessie of taak wilt starten.
• Gebruik codex-reply() als je een bestaande conversatie wilt vervolgen of doorwerken op het net voltooide werk. Er is een conversationId-parameter nodig om het verzoek aan de juiste conversatie te koppelen.

De client_session_timeout_sessions is de maximale tijd dat de client een sessie met de betreffende MCP STDIO-server openhoudt. We kiezen een royale 360.000 seconden (100 uur) voor Codex, zodat langlopende workflows dezelfde MCP-sessie kunnen hergebruiken zonder idle-time-outs.

Community-wrappers

De community heeft ook wrappers gemaakt die dit nog makkelijker maken. Een opvallend project is de codex-mcp-wrapper-repo op GitHub. Deze wrapper is specifiek ontworpen om Codex te integreren in andere omgevingen, zoals Claude Code.

Een Codex CLI MCP multi-agent finance-pijplijn orkestreren

Nu we weten hoe we Codex als server draaien, bekijken we een praktijkscenario waarin dit krachtig wordt. We orkestreren een multi-agentpijplijn waarin meerdere AI-agents samenwerken om de upgrade van ons financedashboard aanzienlijk te versnellen ten opzichte van één agent.

Als multi-agentdesign abstract voelt, vind je hier een heldere uitleg van gangbare agentarchitecturen en wanneer multi-agentopstellingen echt helpen.

Risico- en UI-agents coördineren

In deze setup gebruiken we een Python-script als orkestrator om de workflow te managen. In plaats van één agent alles te laten doen, starten we twee gespecialiseerde agents:

• Codex-Risk, gericht op kwantitatieve analyse
• Codex-UI, gericht op frontendimplementatie

Omdat we Codex nu als headless MCP-server draaien vanuit de Agents SDK, moeten zowel de SDK als de Codex-processen authenticeren bij OpenAI, niet alleen de interactieve Codex CLI.

Houd het simpel en betrouwbaar: zorg dat OPENAI_API_KEY (of optioneel CODEX_API_KEY) in je omgeving is ingesteld vóór je de orkestrator draait, zodat elke schakel met de modellen kan praten. Voer in een nieuwe terminal het volgende uit:

export OPENAI_API_KEY=<your-key>

We initialiseren twee onafhankelijke Codex MCP-servers in een async with-blok voor stabiele, geïsoleerde verbindingen (één proces per agent), wat hen daadwerkelijk in parallel laat draaien. Dit is het orkestratiescript 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())

Voer in hetzelfde terminalvenster waarin je je OpenAI API-sleutel hebt ingesteld het orkestratiescript uit:

python orchestrator.py

Deze agents gaan onafhankelijk aan de slag, raadplegen via MCP de Alpha Vantage-documentatie, halen de historische data op en schrijven de Python- of TypeScriptlogica om de Value at Risk voor je portefeuille te berekenen.

Nadat de twee Codex-instanties de vereiste wijzigingen hebben doorgevoerd, kun je ze visualiseren door opnieuw het commando npm run dev te draaien om het eindresultaat in de browser te bekijken. Het ziet er ongeveer zo uit:

Door deze verantwoordelijkheden te splitsen, verandert een proces dat normaal 20 minuten heen-en-weer chatten kost in een volledig geautomatiseerde pijplijn. De Risk Agent regelt de wiskunde, de UI Agent de implementatie, en je dashboard wordt in seconden bijgewerkt.

Parallelle taakuitvoering

De echte magie zit in het uitvoeringsmodel. In een standaard chatinterface zijn toolcalls sequentieel; je moet wachten tot de data is opgehaald voordat je kunt vragen om de grafiek te updaten.

Met MCP en deze multi-agentaanpak bereiken we echte gelijktijdigheid. Terwijl de Codex-Risk-agent wacht op netwerkverzoeken naar de Alpha Vantage API, kan de Codex-UI-agent al kolommen in de tabel opzetten en de CSS-klassen voorbereiden.

Door deze splitsing reduceer je een proces dat 15 à 20 minuten kan kosten tot een gestroomlijnde pijplijn. Van ruwe data-ophaal naar complexe risicoanalyse tot volledig geïmplementeerde UI-features in circa 5 minuten.

Beveiliging en beperkingen

Zoals bij elke krachtige tool die je code met de buitenwereld verbindt, moeten we het over veiligheid hebben. Hoewel Codex en MCP enorme mogelijkheden ontsluiten, introduceren ze ook nieuwe aanvalsvlakken en praktische beperkingen om rekening mee te houden voordat je in productie gaat.

Configuratiekwetsbaarheden

Het belangrijkste beveiligingsaspect betreft het configuratiebestand zelf. In eerdere versies van de Codex CLI was er een bekende kwetsbaarheid waarbij kwaadaardige commando’s konden worden geïnjecteerd via het config.toml-bestand in combinatie met een .env-bestand dat CODEX_HOME omleidde naar een lokale map. Dit is gepatcht, dus het is cruciaal dat je versie v0.23.0 of hoger gebruikt.

Toch verdwijnt het risico niet volledig met software-updates. Omdat Codex projectspecifieke configuraties respecteert, kan het klonen van een repository met een kwaadaardig .codex/config.toml-bestand én een .env-bestand dat CODEX_HOME=./.codex instelt ertoe leiden dat codex in die map onverwachte commando’s draait die in dat bestand staan.

Maak er een gewoonte van om het configuratiebestand van elk nieuw gekloond project te controleren. Behandel het met de grootst mogelijke voorzichtigheid voordat je iets draait.

MCP-beperkingen

Praktisch gezien zijn er wat ruwe kantjes. Er is momenteel geen ingebouwde “connectiviteitstest” wanneer je de CLI start. Codex meldt niet automatisch of een MCP-server down of onbereikbaar is bij het opstarten. Je moet het model in feite iets vragen als “Check my tools” zodat het kan verifiëren dat de verbinding werkt.

Verder is het verleidelijk om álle beschikbare tools te installeren, maar je moet selectief zijn. Als je te veel MCP-servers koppelt, begint de prestatie van het model aanzienlijk te verslechteren. Hoe meer tools je toevoegt, hoe meer “ruis” het model moet wegfilteren, wat kan verwarren of leiden tot hallucinaties. Koppel alleen de MCP-servers die je nodig hebt.

Codex CLI vs Claude Code

Tot slot is het de moeite waard om Codex CLI te vergelijken met de naaste concurrent, Claude Code.

Als je inzet op automatisering en CI-pijplijnen, is Codex CLI doorgaans de betere keuze. Het is lichtgewicht, gebruiksvriendelijk en goed te scripten. Claude Code blinkt juist uit als interactieve code-ervaring in de editor, met sterke ingebouwde UX voor refactors, testruns en per-projectassistenten.

Ook de configuratiestijl verschilt. Codex gebruikt TOML-bestanden, met een gedeeld ~/.codex/config.toml dat door zowel de CLI als de IDE-extensie wordt gebruikt, plus optionele projectoverschrijvingen via .codex/config.toml per repo. Je omgeving is dus standaard gedeeld, maar per project aanpasbaar.

Claude Code gebruikt doorgaans JSON-instellingen, met een globale config (bijv. ~/.claude.json) en extra projectspecifieke bestanden (zoals .mcp.json of projectinstellingen) waarmee elke repository zijn eigen MCP-servers en gedrag kan definiëren—meer isolatie, maar iets meer setup per project.

Beide tools vertegenwoordigen de voorhoede van AI-codeagents; de keuze hangt af van je workflow: als je de agent vooral in een terminal of CI-job ziet leven, past Codex vaak beter, terwijl als je primair een editor-first codecompagnon wilt, Claude Code voelt vaak natuurlijker.

Voor een diepere duik in deze vergelijking raad ik onze Codex vs Claude Code-gids aan.

Conclusie

We hebben vandaag veel behandeld, van de basisdefinities van MCP tot het bouwen van onze eigen Codex-agent. Als je één ding meeneemt uit deze tutorial, laat het dan de kracht van de workflow zijn. Het hele proces—je MCP-server configureren, Codex draaien, en zien hoe de tools automatisch de data vinden die ze nodig hebben—laat je features sneller bouwen dan een mens ooit zou kunnen.

Begin je net, maak het dan niet meteen te complex. Start met Context7 voor documentatie en misschien één API-gebaseerde MCP, zoals de Alpha Vantage-setup van vandaag. Raak vertrouwd met die flow voordat je met meerdere agents gaat werken.

Heb je dat vertrouwen, dan is de lucht de limiet. Verken andere MCP’s. Koppel Figma om UI-code rechtstreeks uit designs te genereren, of sluit Sentry aan zodat Codex automatisch production bugs analyseert en oplost. Experimenteer met Codex-subagents en kijk hoeveel routinewerk je kunt delegeren. De tools zijn er, krachtig, en klaar voor gebruik.

Ben je geïnteresseerd in het bouwen van AI-applicaties, schrijf je dan in voor onze skill track AI Engineering with LangChain. De lesstof is AI-native, wat betekent dat je een persoonlijke tutor krijgt die je precies de skills leert die je nodig hebt om vanaf jouw niveau een echte pro te worden in het ontwerpen van AI-workflows.