Codex vs Claude Code：AI 编程 Agent 双雄对比

┌────────────────────────────────┐
│       Codex Agent Loop         │
│  ┌──────┐  ┌──────┐  ┌──────┐ │
│  │ 感知 │→│ 规划 │→│ 行动 │ │
│  └──────┘  └──────┘  └──────┘ │
│       ↓         ↑             │
│  ┌──────────────────────────┐ │
│  │    技能系统 (Skills)     │ │
│  │  ┌─────┐ ┌─────┐ ┌────┐ │ │
│  │  │ 编程│ │浏览器│ │文件│ │ │
│  │  └─────┘ └─────┘ └────┘ │ │
│  └──────────────────────────┘ │
│       ↓                       │
│  ┌──────────────────────────┐ │
│  │   模型层 (可替换)        │ │
│  │  GPT-4o / Claude / Qwen  │ │
│  └──────────────────────────┘ │
└────────────────────────────────┘

┌────────────────────────────────┐
│     Claude Code Agent          │
│  ┌──────┐  ┌──────┐  ┌──────┐ │
│  │ 理解 │→│ 规划 │→│ 执行 │ │
│  └──────┘  └──────┘  └──────┘ │
│       ↓                       │
│  ┌──────────────────────────┐ │
│  │  内置工具集               │ │
│  │  Read/Write/Bash/Search  │ │
│  └──────────────────────────┘ │
│       ↓                       │
│  ┌──────────────────────────┐ │
│  │  Claude 模型 (绑定)      │ │
│  │  Claude 4 / Claude 3.5   │ │
│  └──────────────────────────┘ │
└────────────────────────────────┘

# Codex CLI
codex "重构 auth 模块，提取 JWT 逻辑到独立文件"
codex --model qwen2.5-coder "审查最近的 3 个 commit"
codex --skill web-scraper "抓取这个页面的所有产品价格"

# Claude Code CLI
claude "重构 auth 模块，提取 JWT 逻辑到独立文件"
claude --model claude-4-sonnet "审查最近的 3 个 commit"

{
  "modelRouting": {
    "coding": "qwen2.5-coder-32b",
    "reasoning": "o3",
    "writing": "claude-4-sonnet",
    "simple": "phi-4"
  }
}

import httpx
import asyncio
from functools import lru_cache
from datetime import timedelta

class CachedAPIClient:
    def __init__(self, base_url: str, cache_ttl: int = 300):
        self.base_url = base_url
        self.cache_ttl = cache_ttl
        self._cache: dict[str, tuple[float, Any]] = {}
    
    async def get(self, endpoint: str) -> dict:
        # 检查缓存
        if endpoint in self._cache:
            ts, data = self._cache[endpoint]
            if time.time() - ts < self.cache_ttl:
                return data
        
        # 请求并缓存
        async with httpx.AsyncClient() as client:
            resp = await client.get(f"{self.base_url}/{endpoint}")
            resp.raise_for_status()
            data = resp.json()
            self._cache[endpoint] = (time.time(), data)
            return data

from httpx import AsyncClient
from typing import Any
import time

class CachedAPIClient:
    """Async API client with TTL-based caching."""
    
    def __init__(self, base_url: str, cache_ttl_seconds: int = 300) -> None:
        self._base_url = base_url.rstrip("/")
        self._ttl = cache_ttl_seconds
        self._cache: dict[str, tuple[float, dict[str, Any]]] = {}
        self._client = AsyncClient(base_url=self._base_url)
    
    async def get(self, endpoint: str) -> dict[str, Any]:
        cached = self._cache.get(endpoint)
        if cached and (time.monotonic() - cached[0]) < self._ttl:
            return cached[1]
        
        response = await self._client.get(endpoint)
        response.raise_for_status()
        data = response.json()
        self._cache[endpoint] = (time.monotonic(), data)
        return data
    
    async def close(self) -> None:
        await self._client.aclose()