Servidor OpenClaw en AWS: tu asistente de IA personal 24/7 en Telegram

La idea de este post es mostrar cómo monté una asistente de IA personal corriendo 24/7 en un VPS de AWS, accesible desde cualquier lugar por Telegram, que elige automáticamente el modelo más barato disponible antes de caer en opciones pagas. El corazón de todo es el OpenClaw: un daemon open source (MIT, TypeScript, Node 24) que expone una asistente única en varios canales (Telegram, Slack, Discord, Signal, iMessage, Matrix, WeChat) y rutea cada pedido por una stack configurable de proveedores y modelos con failover incorporado.

Lo interesante: OpenClaw ya implementa una cascada de fallback nativa. Configuro modelos gratis primero y escala automáticamente cuando un tier se agota. Claude queda gateado al final, solo activado por comando explícito.

Lo que vas a tener al final

• VPS Ubuntu en AWS corriendo OpenClaw como daemon systemd.
• Bot de Telegram bloqueado a tu ID numérico (nadie más puede mandarle DM).
• Cascada de cuatro tiers: OpenRouter gratis, MiniMax Coding Plan, Codex via ChatGPT, Anthropic Claude (bajo demanda).
• Sandbox Docker para cuando la asistente quiera ejecutar shell.
• Backup diario del estado a S3.
• Costo recurrente de ~$60/mes, sin contar el Claude oportunístico.

Visión general de la arquitectura

                  [ tu celular ]
                         |
                         | Telegram DM
                         v
                  api.telegram.org
                         |
                         | long-poll (solo salida)
                         v
+--------------------------------------------------------+
|  VPS AWS (Ubuntu 24.04, Lightsail $20/mes)             |
|                                                        |
|   systemd user unit: openclaw.service                  |
|     openclaw gateway (Node 24)  puerto 18789 (lo)      |
|       canal: telegram (grammY long-poll)               |
|       runtime de agentes (sandbox: Docker)             |
|       cascada de modelos -- HTTPS de salida ----+      |
|                                                 |      |
|   ~/.openclaw/                                  |      |
|     openclaw.json    config + chain             |      |
|     auth-profiles    OAuth tokens, API keys     |      |
|     workspace/       estado por agente          |      |
+-------------------------------------------------|------+
                                                  |
        +----------------+--------------+---------+-------+
        v                v              v                 v
  openrouter.ai    api.minimax.io   ChatGPT (Codex)  api.anthropic.com
   (modelos gratis) (Coding Plan)   (tu sub)         (gateado)

Por qué esta forma:

• Ningún puerto público. Telegram hace polling hacia afuera; el Gateway solo escucha en 127.0.0.1:18789. Security group expone solo SSH.
• Los cuatro proveedores se alcanzan por HTTPS de salida. Sin infraestructura extra.
• Estado en una carpeta (~/.openclaw/). Backup a S3 trivial.
• Un solo daemon Node. No hace falta orquestar Docker para el core.

Por qué la cascada funciona nativamente en OpenClaw

La doc del OpenClaw en docs.openclaw.ai/concepts/model-failover lo deja explícito:

OpenClaw maneja fallas en dos etapas: (1) rotación de auth profile dentro del proveedor actual, después (2) fallback de modelo al próximo modelo en agents.defaults.model.fallbacks.

Lo que esto me da gratis:

Ese comportamiento de “override del usuario es estricto” es la clave: cuando yo escribo /model anthropic/..., OpenClaw traba la sesión en Claude hasta que reseteo, y una falla en Claude vuelve como error en lugar de rutear silenciosamente a un tier más barato. Es exactamente el “Claude requiere permiso” que quería.

Hospedaje: EC2 vs Lightsail

El Gateway es un único proceso Node más un sandbox Docker opcional. La RAM es el cuello de botella.

Recomendación: Lightsail $20/mes. Costo flat predecible, egress incluido, sin fee de EIP. Mismo Ubuntu 24.04 por debajo, así que todo comando de esta guía funciona igual. Tamaños abajo (Lightsail $10 o t3.small con 2 GB) quedan apretados: Node 24 más el sandbox Docker pasa de 2 GB en turnos pesados.

Pre-requisitos

En el Mac (una sola vez)

brew install awscli
aws configure
brew install --cask tailscale   # opcional pero recomendado

Cuentas a tener listas

• AWS con IAM user y AmazonLightsailFullAccess.
• OpenRouter (signup gratis, ~2 min).
• MiniMax con Coding Plan activo.
• ChatGPT Plus/Pro/Business/Edu/Enterprise.
• Anthropic Console con método de pago configurado.
• Telegram instalado en el celular.

Paso 1: provisionar el VPS

REGION="sa-east-1"

aws lightsail create-instances \
  --instance-names openclaw-1 \
  --availability-zone "${REGION}a" \
  --blueprint-id ubuntu_24_04 \
  --bundle-id medium_3_0 \
  --tags key=Name,value=openclaw

aws lightsail get-instance --instance-name openclaw-1 \
  --query 'instance.state.name' --output text

# Restringir SSH a mi IP actual
MY_IP=$(curl -s https://checkip.amazonaws.com)
aws lightsail put-instance-public-ports \
  --instance-name openclaw-1 \
  --port-infos "fromPort=22,toPort=22,protocol=TCP,cidrs=${MY_IP}/32"

# Bajar la SSH key default de la región
aws lightsail download-default-key-pair --query 'privateKeyBase64' --output text \
  | base64 -d > ~/.ssh/lightsail-${REGION}.pem
chmod 400 ~/.ssh/lightsail-${REGION}.pem

PUBLIC_IP=$(aws lightsail get-instance --instance-name openclaw-1 \
  --query 'instance.publicIpAddress' --output text)

ssh -i ~/.ssh/lightsail-${REGION}.pem ubuntu@${PUBLIC_IP}

Ya dentro de la máquina, hostname y timezone:

sudo hostnamectl set-hostname openclaw
sudo timedatectl set-timezone America/Sao_Paulo
sudo apt update && sudo apt upgrade -y

Paso 2: instalar OpenClaw

OpenClaw trae un script de install que baja Node 24 y el binario, e instala el daemon systemd.

Fijar Node 24

curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
sudo apt install -y nodejs
node --version    # esperar v24.x
npm --version

Instalar OpenClaw

curl -fsSL https://openclaw.ai/install.sh | bash

which openclaw
openclaw --version

Onboarding mínimo

# Podés elegir "skip" o solo ANTHROPIC_API_KEY por ahora.
# La config de la cascada va en el próximo paso.
openclaw onboard --install-daemon

openclaw gateway status
# Esperar: "running on 127.0.0.1:18789"

ls ~/.openclaw/

Para chequear la Control UI desde el laptop:

ssh -i ~/.ssh/lightsail-sa-east-1.pem -L 18789:127.0.0.1:18789 ubuntu@${PUBLIC_IP}

# Abro http://127.0.0.1:18789 localmente.
ssh -i ~/.ssh/... ubuntu@${PUBLIC_IP} 'cat ~/.openclaw/.env | grep TOKEN'

Paso 3: configurar la cascada de cuatro tiers

3.1 Conseguir las credenciales

Los cuatro tutoriales de key están en Tutoriales de key abajo. Al final necesito:

• OPENROUTER_API_KEY (sk-or-v1-…)
• MINIMAX_API_KEY (o OAuth via openclaw onboard --auth-choice minimax-global-oauth)
• Token OAuth de Codex via openclaw onboard --auth-choice openai-codex-oauth
• ANTHROPIC_API_KEY (sk-ant-…)

3.2 Poner las keys en .env

cat > ~/.openclaw/.env <<'EOF'
# Tier 1 -- OpenRouter (modelos gratis)
OPENROUTER_API_KEY=sk-or-v1-REPLACE_ME

# Tier 2 -- MiniMax Coding Plan ($20/mes). Comentar si usaste OAuth.
MINIMAX_API_KEY=REPLACE_ME

# Tier 4 -- Anthropic API key (gateado; solo via /model)
ANTHROPIC_API_KEY=sk-ant-REPLACE_ME

# Telegram (lo lleno en el Paso 4)
# TELEGRAM_BOT_TOKEN=
EOF

chmod 600 ~/.openclaw/.env

El Tier 3 (Codex) entra por OAuth, no env var. El token aterriza en ~/.openclaw/agents/<id>/agent/auth-profiles.json.

3.3 Editar openclaw.json con la cadena

cp ~/.openclaw/openclaw.json ~/.openclaw/openclaw.json.bak

openclaw config set agents.defaults.model.primary 'openrouter/qwen/qwen3-coder:free'

openclaw config set --strict-json --merge agents.defaults.model.fallbacks '[
  "openrouter/z-ai/glm-4.5-air:free",
  "openrouter/openai/gpt-oss-120b:free",
  "minimax/MiniMax-M2.7",
  "openai-codex/gpt-5.5"
]'

# Permitir Claude para elegirlo manual con /model. No está en la cadena automática.
openclaw config set --strict-json --merge agents.defaults.models '{
  "openrouter/qwen/qwen3-coder:free":     {"alias": "free-coder"},
  "openrouter/z-ai/glm-4.5-air:free":     {"alias": "free-glm"},
  "openrouter/openai/gpt-oss-120b:free":  {"alias": "free-oss"},
  "minimax/MiniMax-M2.7":                 {"alias": "minimax"},
  "openai-codex/gpt-5.5":                 {"alias": "codex"},
  "anthropic/claude-opus-4-7":            {"alias": "claude"}
}'

openclaw config get agents.defaults.model
openclaw config get agents.defaults.models

3.4 Comportamiento en runtime

Es exactamente el comportamiento que quería: free-to-Codex automático; Claude solo por acción explícita.

3.5 Opcional: agente “premium” siempre en Claude

En vez de tipear /model cada vez, defino un segundo agente:

openclaw config set --strict-json --merge agents.list '[
  {
    "id": "premium",
    "model": { "primary": "anthropic/claude-opus-4-7", "fallbacks": [] },
    "system": "Sos el tier premium. Usá con prudencia."
  }
]'

fallbacks: [] lo hace estricto: falla en Claude no baja silenciosamente.

3.6 Reiniciar para aplicar

openclaw gateway restart
openclaw doctor

Paso 4: enchufar Telegram

4.1 Crear el bot

En la app de Telegram, en el celular:

1. Abrir chat con @BotFather (verificar que el username es exactamente @BotFather).
2. Mandar /newbot.
3. Elegir un display name (tipo Mi OpenClaw).
4. Elegir un username terminado en bot (tipo mi_openclaw_bot).
5. Guardar el token que manda BotFather. Algo como 123456789:ABCDef-GhIjKlMnOpQrStUv.
6. Mandar /setprivacy, elegir el bot, Disable (deja al bot ver mensajes en grupos; solo importa si lo vas a agregar a grupos).
7. Mandar /setjoingroups, Disable (no querés que aleatorios lo agreguen).

4.2 Encontrar mi ID numérico de Telegram

# En el VPS, sigo el log y mando cualquier cosa al bot desde el celu
openclaw logs --follow
# Busco una línea con "from.id": 123456789

Ese número es el <mi-id-telegram>.

4.3 Configurar el canal

echo "TELEGRAM_BOT_TOKEN=123456789:ABC..." >> ~/.openclaw/.env

openclaw config set --strict-json --merge channels.telegram '{
  "enabled": true,
  "dmPolicy": "allowlist",
  "allowFrom": ["telegram:<mi-id-telegram>"]
}'

# Me marco como dueña de los comandos (libera /model, /reset, etc.)
openclaw config set --strict-json --merge commands.ownerAllowFrom '["telegram:<mi-id-telegram>"]'

openclaw gateway restart
openclaw doctor

dmPolicy: "allowlist" bloquea cualquier otro usuario de Telegram que mande DM al bot, aunque se filtre el username.

4.4 Smoke test

En Telegram, mando hola al bot. En unos segundos llega respuesta servida por qwen3-coder:free.

Probando escalar manualmente:

/model claude
escribí un decorator de Python que reintenta con backoff exponencial
/new

/model claude cambia a Claude para esa sesión; /new resetea a la cascada.

Paso 5: blindaje de seguridad

El modelo de amenaza: un daemon de larga duración con credenciales para ChatGPT, Claude, MiniMax, OpenRouter, y un bot de Telegram que puede correr shell en su sandbox. Hay que mantener apretadas las superficies de entrada y salida.

5.1 Firewall de entrada

Lightsail/EC2 SG solo expone puerto 22 desde mi IP. El Gateway ya escucha en loopback (gateway.bind: "lan" es default; verifico con openclaw config get gateway.bind. Si no necesito LAN, lo dejo en "lo").

sudo ss -tlnp | grep -v 127.0.0.1
# Debería ver solo :22 (sshd)

5.2 Trabar el pareo de DM

Hecho en el Paso 4. Verifico:

openclaw config get channels.telegram.dmPolicy   # esperar "allowlist"
openclaw config get channels.telegram.allowFrom  # esperar ["telegram:..."]

5.3 Sandbox de la herramienta de shell

Si voy a dejar a la asistente correr shell (que es la mitad del propósito), prendo el sandbox Docker para que no toque el filesystem fuera de ~/.openclaw/workspace/.

curl -fsSL https://get.docker.com | sudo bash
sudo usermod -aG docker ubuntu
newgrp docker

openclaw config set agents.defaults.sandbox.mode 'non-main'
openclaw config set agents.defaults.sandbox.backend 'docker'

openclaw gateway restart
openclaw doctor

La sesión main (DMs directas) sigue con acceso al host por default, útil para trabajar de verdad. Sesiones de grupo o multi-usuario quedan sandboxed.

5.4 Proteger el cofre de credenciales

chmod 600 ~/.openclaw/.env
chmod 700 ~/.openclaw/agents
find ~/.openclaw -name 'auth-profiles.json' -exec chmod 600 {} \;

5.5 Opcional: Tailscale en lugar de SSH público

Si no quiero SSH en internet pública:

curl -fsSL https://tailscale.com/install.sh | sudo bash
sudo tailscale up --ssh

# Y cierro el puerto 22 en el SG de Lightsail/EC2.
# SSH solo via MagicDNS de Tailscale: ssh ubuntu@openclaw

5.6 Checklist pre-vuelo

• Gateway en loopback (gateway.bind = "lo" o "lan" solamente)
• dmPolicy: "allowlist" con mi ID numérico
• commands.ownerAllowFrom con mi ID numérico
• ~/.openclaw/.env en 0600
• Sandbox prendido para sesiones non-main
• SSH restricto a mi IP (o cerrado via Tailscale)
• openclaw doctor en verde

Paso 6: correr como servicio systemd

openclaw onboard --install-daemon ya creó el user unit. Solo verifico y aprieto.

systemctl --user status openclaw

# Si no aparece:
openclaw daemon install --user

# Lingering para sobrevivir logout
sudo loginctl enable-linger ubuntu

# Auto-arranque en boot
systemctl --user enable openclaw

# Logs
journalctl --user -u openclaw -f

# Restart / stop / start
systemctl --user restart openclaw
systemctl --user stop openclaw
systemctl --user start openclaw

El daemon corre como usuario ubuntu (sin root), lee ~/.openclaw/.env y escribe estado en ~/.openclaw/. Restart-on-crash incorporado.

Paso 7: persistencia y backups

Todo lo que importa vive en ~/.openclaw/. Snapshot nocturno a S3:

sudo apt install -y awscli
aws configure   # IAM key con privilegios mínimos, PutObject en un bucket

cat > ~/backup-openclaw.sh <<'EOF'
#!/bin/bash
set -euo pipefail
BUCKET="s3://mi-bucket/openclaw-backups"
TS=$(date -u +%Y%m%d-%H%M%S)
cd ~
tar --exclude='.openclaw/workspace/*/node_modules' \
    --exclude='.openclaw/agents/*/sessions/cache' \
    -czf /tmp/openclaw-${TS}.tar.gz .openclaw

aws s3 cp /tmp/openclaw-${TS}.tar.gz "${BUCKET}/openclaw-${TS}.tar.gz" \
  --storage-class STANDARD_IA

rm /tmp/openclaw-${TS}.tar.gz

# Mantener los últimos 14 días
aws s3 ls "${BUCKET}/" | sort | head -n -14 | awk '{print $4}' | while read f; do
  aws s3 rm "${BUCKET}/${f}"
done
EOF
chmod +x ~/backup-openclaw.sh

( crontab -l 2>/dev/null; echo "0 3 * * * /home/ubuntu/backup-openclaw.sh" ) | crontab -

Snapshot del disco entero del Lightsail ($0.05/GB/mes) es una alternativa más burda y más simple.

Tutoriales de key

1. OpenRouter (tier gratis)

OpenRouter es una API única que hace proxy a cientos de LLMs. El tier gratis (sufijo :free en el model id) da ~50 requests/día por cuenta; sube a 1.000/día si cargo $10 en créditos vitalicios (esos créditos no se consumen con modelos gratis, solo desbloquean cuota).

1. Ir a openrouter.ai. Login con Google, GitHub o magic link. Sin teléfono, sin KYC.
2. Abrir openrouter.ai/keys, Create Key, opcionalmente fijar un cap de crédito.
3. Copiar el token sk-or-v1-... (mostrado una vez).
4. Opcional: en openrouter.ai/credits cargar $10. Sube el cap de modelos gratis de 50/día a 1.000/día en todos los :free combinados. Los $10 quedan parados; solo uso pago resta.

Test rápido:

export OPENROUTER_API_KEY=sk-or-v1-...
curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen/qwen3-coder:free",
    "messages": [{"role":"user","content":"hola"}]
  }'

Límites a abril de 2026:

2. MiniMax Coding Plan (Plus, $20/mes)

El Token Plan de MiniMax es una subscription mensual real, no top-up de crédito. El tier Plus da 4.500 requests por ventana móvil de 5h en MiniMax-M2.7.

1. Ir a platform.minimax.io. Sign up con email más verificación.
2. Suscribirse al Coding Plan / Token Plan Plus, $20/mes.
3. Account, Token Plan en el dashboard.
4. Copiar la Token Plan API Key (separada de la pay-as-you-go, solo válida mientras la subscription esté activa).
5. Camino headless: poner MINIMAX_API_KEY=... en ~/.openclaw/.env y usar el ref minimax/MiniMax-M2.7. Camino OAuth en desktop: openclaw onboard --auth-choice minimax-global-oauth, usando minimax-portal/MiniMax-M2.7.

Cuando la ventana de 5h se agota, la Token Plan API key devuelve 429 y la cascada avanza a Codex.

3. OpenAI Codex (via subscription de ChatGPT)

Codex CLI es el agente de coding oficial de OpenAI en Rust. Con ChatGPT Plus/Pro/Business autentico por OAuth, sin API key separada, sin cobro por token. Los límites siguen tu plan de ChatGPT (ventanas de 5h, cap semanal).

El callback OAuth pega en localhost:1455, lo cual es molesto en VPS headless. Tres caminos.

Camino A: SSH port-forward (más confiable)

1. Desde el laptop, SSH con forward:

   ssh -L 1455:localhost:1455 -i ~/.ssh/lightsail-...pem ubuntu@${PUBLIC_IP}
   

2. En el VPS:

   openclaw onboard --auth-choice openai-codex-oauth
   

3. La CLI imprime URL https://auth.openai.com/.... La abro en el navegador del laptop.
4. Login con la cuenta ChatGPT, apruebo, callback pega en localhost:1455. Por el -L, se resuelve dentro del VPS, completando el flow.
5. OpenClaw escribe el token en ~/.openclaw/agents/<id>/agent/auth-profiles.json.

Camino B: device-code

openclaw onboard --auth-choice openai-codex-oauth --device-code

Imprime un código; abro la URL en cualquier navegador, pego el código, apruebo. Funciona en cuenta personal; ChatGPT Business/Team requiere admin habilitando antes.

Camino C: copiar auth.json desde un login en desktop

# En el Mac
brew install --cask codex
codex login

# Copiar credenciales
ssh -i ~/.ssh/... ubuntu@${PUBLIC_IP} 'mkdir -p ~/.codex'
scp -i ~/.ssh/... ~/.codex/auth.json ubuntu@${PUBLIC_IP}:~/.codex/auth.json

# En el VPS
openclaw onboard --auth-choice openai-codex-oauth --import ~/.codex/auth.json

Atención: el refresh token de Codex es prácticamente single-use. Si dos máquinas usan la misma credencial y una hace refresh, la otra queda inválida. El Camino A es el más estable para deploy de larga duración.

4. Anthropic Claude (API key)

Claude es el tier gateado. No lo pongo en la cascada automática; solo lo invoco con /model.

1. Ir a console.anthropic.com.
2. Cadastro/login. Configurar billing (necesita método de pago antes de que la key responda con algo útil).
3. Settings, API Keys, Create Key. Le pongo nombre openclaw. Copio el sk-ant-... (mostrado una vez).
4. Opcional: en Limits, cap mensual (recomiendo $50/mes para uso personal).
5. Agregar al .env:

   echo 'ANTHROPIC_API_KEY=sk-ant-...' >> ~/.openclaw/.env
   chmod 600 ~/.openclaw/.env
   

6. Restart: systemctl --user restart openclaw.

Test en Telegram:

/model anthropic/claude-opus-4-7
explicame la diferencia entre Promise.all y Promise.allSettled
/new

/new retorna la sesión al primary de la cascada para no quemar crédito Anthropic al pedo.

Referencia de modelos gratis del OpenRouter

Estos son los tres modelos gratis que vale la pena encadenar, en orden. Todos aceptan tools, todos por <id>:free.

¿Por qué tres gratis en fila en lugar de solo uno? Endpoints gratis throttlean seguido en horario comercial de EE.UU. Un único modelo gratis significa que un burst de 429 te tira directo al MiniMax (cuota paga). Tres modelos diversos absorben throttles cortos sin gastar.

Costo estimado

Mensualidad

Comparado con “Claude todo el tiempo”

Tiempo de setup

~90 minutos de punta a punta:

• Provisionar Lightsail: 5 min
• Install + onboard: 10 min
• Cadastros y recolección de keys: ~30 min (mayormente esperando email de verificación)
• Config de la cascada: 10 min
• Setup de Telegram: 10 min
• Hardening: 15 min
• Smoke testing: 10 min

Operación día a día

Desde el celular (Telegram)

Desde el VPS (SSH)

# Logs
journalctl --user -u openclaw -f

# Hot-edit sin restart
openclaw config set agents.defaults.model.primary 'minimax/MiniMax-M2.7'
openclaw gateway reload

# Salud de los auth profiles
openclaw doctor
openclaw models auth list

# Qué modelo sirvió el último mensaje
openclaw sessions list
openclaw sessions history --session <id>

# Actualizar OpenClaw
npm install -g openclaw@latest
systemctl --user restart openclaw

Cuando la cascada se porta mal

Sacar un tier de circulación:

# Deshabilitar temporalmente
openclaw models auth disable openrouter:default

# Rehabilitar
openclaw models auth enable openrouter:default

# Forzar tier específico
openclaw config set agents.defaults.model.primary 'minimax/MiniMax-M2.7'
openclaw gateway reload

Troubleshooting

El bot de Telegram no responde

openclaw gateway status
openclaw config get channels.telegram
openclaw doctor
openclaw logs --follow

# Sospechoso común: dmPolicy=allowlist con ID errado
openclaw config get channels.telegram.allowFrom

“Model not allowed”

Significa que usé /model X donde X no está en agents.defaults.models. Lo agrego:

openclaw config set --strict-json --merge agents.defaults.models \
  '{"openai/gpt-4o": {"alias": "gpt4o"}}'

La cascada no pasa del tier gratis

openclaw logs --follow | grep -i 'failover\|429\|cooldown'
openclaw config get agents.defaults.model.fallbacks

Si el array de fallbacks está vacío, reaplico el JSON del paso 3.3.

OAuth de Codex falló en el refresh

openclaw onboard --auth-choice openai-codex-oauth --reauth

Out of memory en un turno

El sandbox Docker compite con Node por RAM en host de 4 GB. O subo a Lightsail large_3_0 (8 GB, $40/mes), o apago el sandbox (agents.defaults.sandbox.mode = "off", menos seguro).

Referencias

OpenClaw

• Repo: github.com/openclaw/openclaw
• Docs: docs.openclaw.ai
• Getting started: docs.openclaw.ai/start/getting-started
• Model failover: docs.openclaw.ai/concepts/model-failover
• Telegram channel: docs.openclaw.ai/channels/telegram
• Sandbox: docs.openclaw.ai/gateway/sandboxing
• Tailscale: docs.openclaw.ai/gateway/tailscale

Dashboards de proveedores

• OpenRouter keys: openrouter.ai/keys
• MiniMax: platform.minimax.io
• OpenAI Platform: platform.openai.com/api-keys
• Anthropic Console: console.anthropic.com
• Codex CLI: github.com/openai/codex