¿Qué es AWS Emulator y cómo se instala? Prueba apps de AWS en local con Claude Code y Codex (probado en 1.0.322)

AWS Emulator es el emulador local oficial de las API de AWS, con disponibilidad general desde el 11 de noviembre de 2026 (hora de EE. UU.). No tiene cargo adicional por el servicio, su código es abierto, no necesita cuenta de AWS y cubre más de 200 servicios. Probamos la versión 1.0.322 en Debian 13: comandos de instalación, AWS CLI apuntando al endpoint local para crear un bucket de S3 y una tabla de DynamoDB, los errores que encontramos y cómo hacer que Claude Code, Codex y Cursor escriban y prueben código contra el emulador.

13 分钟阅读
¿Qué es AWS Emulator y cómo se instala? Prueba apps de AWS en local con Claude Code y Codex (probado en 1.0.322)

AWS Emulator es el emulador local oficial de AWS. Levanta un endpoint HTTPS en tu propia máquina, y el AWS CLI, los SDK de AWS y los agentes de código lo llaman con las mismas API que usan en la nube. No necesitas cuenta de AWS, y nada de lo que crea es un recurso real en la nube. Según el blog AWS News, pasó a disponibilidad general (GA) el 11 de noviembre de 2026 (hora de EE. UU.), es decir, hacia las 2:00 del 12 de noviembre en hora de Pekín.

El 13 de noviembre de 2026 (hora de Pekín, UTC+8) instalamos AWS Emulator 1.0.322, la versión del canal LTS en ese momento, en una máquina Debian 13 x86_64. Con AWS CLI 2.40.1 creamos un bucket de S3, una tabla de DynamoDB, una cola de SQS y una función Lambda. Después pedimos a Claude Code 2.1.319 y a Codex CLI 0.167.0 que escribieran código y ejecutaran pruebas contra el emulador. Todos los comandos, tiempos y salidas de abajo salen de esa ejecución.

Create API Key →

La respuesta corta

PreguntaRespuesta
¿Qué es AWS Emulator?El emulador local oficial de las API de AWS, escrito en Rust y sin interfaz gráfica. Según AWS, está construido a partir de más de 400 modelos de API y cubre más de 200 servicios de AWS.
¿Tiene cargo? ¿Necesito una cuenta de AWS?Según AWS, no hay cargo adicional por el servicio ni hace falta cuenta de AWS. El código está en GitHub bajo la dedicación al dominio público CC0.
¿Cómo se instala?En Linux, instala el paquete RPM o Debian. En macOS y Windows, construye una imagen con el Dockerfile de la documentación oficial (AWS no publica una imagen lista). Los proyectos en Rust también pueden usar el modo embebido.
¿Cómo se usa?Ejecuta aws-emulator. Escucha por defecto en https://127.0.0.1:9297. Define unas pocas variables de entorno para que el AWS CLI y los SDK apunten a él; el código de tu aplicación no cambia.
Resultado de nuestra pruebaDescarga e instalación en unos 6 segundos, y el health check devolvió ok unos 0,3 segundos después de arrancar. S3, DynamoDB, SQS y Lambda funcionaron. Claude Code terminó la misma tarea «S3 + DynamoDB + pytest» en unos 32 segundos y Codex en unos 81 segundos, con 2 passed en ambos.
Lo más importante a vigilarNo evalúa las políticas de IAM como AWS y emula una sola cuenta en una sola Región. Prueba permisos y seguridad en AWS real antes de producción.

Qué es AWS Emulator

Según el blog AWS News, AWS Emulator genera al arrancar sus propias credenciales, un archivo de configuración y un certificado, y los escribe en ~/.aws/emulator/9297/. Cuando las variables de entorno de tu SDK apuntan ahí, las peticiones van a tu máquina en lugar de a AWS. Está construido con los mismos modelos de API que usan los SDK de AWS, así que los datos y errores que devuelve tienen la misma forma que en la nube.

El caso de uso principal son los agentes de código. Según @AWSNewsroom, cada línea del código de AWS Emulator la escribieron agentes de IA autónomos que corren en Amazon Bedrock AgentCore: cientos de agentes, organizados en tres equipos, escriben las pruebas, implementan las funciones y revisan los cambios. Según Swami Sivasubramanian, de AWS, en su artículo invitado en All Things Distributed, los agentes primero escriben «pruebas de fidelidad» y las hacen pasar contra AWS real, y luego construyen el emulador hasta que pasa esas mismas pruebas. El CTO de AWS, @Werner, afirma que fue escrito y probado íntegramente por agentes y que ofrece un entorno de pruebas de alta fidelidad para más de 200 servicios de AWS.

El lanzamiento generó mucha conversación. Según las métricas públicas de X, a primera hora del 13 de noviembre (hora de Pekín), la publicación de lanzamiento de @AWSNewsroom tenía unas 111.000 visualizaciones, 705 me gusta y 206 reposts, y la publicación de lanzamiento de @awsdevelopers unas 78.000 visualizaciones, 1.203 me gusta y 758 guardados. El repositorio de GitHub aws/aws-emulator tenía entonces unas 4.400 estrellas.

Cronología

Fecha (hora de Pekín)Evento
11 de noviembreSale 1.0.322 (aws-emulator -v muestra la fecha de publicación 2026.11.10)
12 de noviembre, hacia las 02:00El blog AWS News, Werner y las cuentas oficiales de AWS anuncian la GA
13 de noviembre, 00:16El paquete LTS/latest que descargamos seguía siendo 1.0.322; a la misma hora apareció v1.0.336 en GitHub Releases

AWS Emulator publica versiones muy a menudo, y el skill oficial pide usar siempre la última, así que probablemente tu número de versión sea más nuevo que el nuestro.

Instalar AWS Emulator

La documentación oficial ofrece cuatro caminos (ver Getting started): dejar que un agente de código con IA lo instale, el paquete de Linux, Docker o el modo embebido de Rust.

Linux: paquete RPM o Debian

bash
# Debian / Ubuntu (x86_64)
curl -fsSLo aws-emulator.deb https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator_amd64.deb
sudo apt-get install -y ./aws-emulator.deb

# Amazon Linux / Fedora / RHEL (x86_64)
sudo dnf install -y https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator-x86_64.rpm

# Comprobar la versión
aws-emulator -v

En máquinas ARM, usa aws-emulator_arm64.deb o aws-emulator-aarch64.rpm. El paquete se instala en /opt/aws-emulator/ y pone el comando aws-emulator en /usr/bin/.

Nuestra salida:

text
Version: 1.0.322
Release date: 2026.11.10
Commit: 7753983c6e495ec3612695b1336bf4936fc7b7fd

El paquete deb ocupa unos 171 MB. La descarga tardó 1,7 segundos, y descarga más apt-get install unos 6 segundos en total. La documentación también describe una verificación GPG: cada paquete tiene al lado un archivo .sig, y tras importar https://downloads.aws.com/keys/gpg/current.asc la huella debe ser 98BC F336 A3BE 53B7 34E9 67C5 2E5B F49B D940 F624. Seguimos esos pasos y obtuvimos Good signature from "SSM Publishing <ssm-publishing@amazon.com>".

macOS / Windows: construir la imagen con el Dockerfile

Según la guía de Docker, AWS no publica una imagen ya construida; la construyes con este Dockerfile. En Apple silicon, cambia x86_64.rpm por aarch64.rpm:

dockerfile
FROM public.ecr.aws/amazonlinux/amazonlinux:2023-minimal
ADD https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator-x86_64.rpm /tmp/aws-emulator.rpm
RUN rpm -i /tmp/aws-emulator.rpm && rm /tmp/aws-emulator.rpm \
 && mkdir -p /home/emulator && chown 1000 /home/emulator
USER 1000
ENV HOME=/home/emulator
EXPOSE 9297
ENTRYPOINT ["aws-emulator", "-b", "0.0.0.0"]
bash
docker build -t aws-emulator .
mkdir -p ~/.aws/emulator
PORT=9297
docker run --rm --memory=2g --memory-swap=2g -p 127.0.0.1:$PORT:$PORT \
  -e HOME="$HOME" -v "$HOME/.aws/emulator:$HOME/.aws/emulator" \
  aws-emulator -p $PORT

Publica el puerto como -p 127.0.0.1:9297:9297, no como -p 9297:9297; la forma corta abre el emulador a todas las máquinas de tu red. Nuestra máquina de prueba no tiene Docker, así que la ruta de Docker la recogimos de la documentación oficial sin ejecutarla.

Arrancarlo y apuntar el AWS CLI hacia él

En una primera terminal, arranca el emulador (-t off desactiva la telemetría anónima, activa por defecto):

bash
aws-emulator -t off

El registro está en formato JSON lines. Una línea indica el endpoint, la configuración y el certificado:

text
"endpoint_url":"https://127.0.0.1:9297","health_check_url":"https://127.0.0.1:9297/__admin/health","config_file":"/home/box/.aws/emulator/9297/config","ca_file":"/home/box/.aws/emulator/9297/ca.pem"

En una segunda terminal, define las variables de entorno. Este conjunto viene del blog AWS News; la última línea borra las credenciales reales de AWS:

bash
export AWS_ENDPOINT_URL=https://127.0.0.1:9297
export AWS_SHARED_CREDENTIALS_FILE=~/.aws/emulator/9297/emulator_credentials
export AWS_CONFIG_FILE=~/.aws/emulator/9297/config
export AWS_EC2_METADATA_DISABLED=true
export AWS_DISABLE_HOST_PREFIX_INJECTION=true
export AWS_REGION=us-east-1
export AWS_DEFAULT_REGION=us-east-1
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE

Primero confirma que hablas con el emulador:

bash
curl --cacert ~/.aws/emulator/9297/ca.pem https://127.0.0.1:9297/__admin/health
aws sts get-caller-identity

En nuestra prueba, el health check devolvió ok unos 0,27 segundos después de arrancar. get-caller-identity devolvió la cuenta fija del emulador, 000000000000, con el ARN arn:aws:iam::000000000000:user/emulator. Si ves esa cuenta, tus peticiones no van a AWS real. En reposo, el emulador usaba unos 283 MB de memoria residente.

Prueba: S3, DynamoDB, SQS, Lambda

bash
aws s3 mb s3://aicodewith-emu-demo
echo "hello from the emulator" > hello.txt
aws s3 cp hello.txt s3://aicodewith-emu-demo/
aws s3 ls s3://aicodewith-emu-demo/

aws dynamodb create-table --table-name notes \
  --attribute-definitions AttributeName=id,AttributeType=S \
  --key-schema AttributeName=id,KeyType=HASH --billing-mode PAY_PER_REQUEST
aws dynamodb wait table-exists --table-name notes
aws dynamodb put-item --table-name notes --item '{"id":{"S":"n1"},"msg":{"S":"hello"}}'
aws dynamodb get-item --table-name notes --key '{"id":{"S":"n1"}}'
OperaciónResultadoTiempo por comando
s3 mb / s3 cp / s3 lsmake_bucket: aicodewith-emu-demo, 24 bytes subidos, hello.txt listadounos 0,55–0,6 s
dynamodb create-tableEstado CREATINGunos 0,5 s
put-item justo después de crear la tablaResourceNotFoundException: Requested resource not foundunos 0,5 s
put-item / get-item tras wait table-existsEscritura correcta; leído {"id":"n1","msg":"hello"}unos 0,5 s
sqs create-queue / send-message / receive-messageSe recibió el cuerpo del mensaje "hi"unos 0,5 s
lambda create-function (Python 3.13) + invokeStatusCode: 200; la función devolvió {"ok": true, "echo": {"a": 1}}unos 0,6 s

Casi todo el medio segundo por comando es el arranque del propio AWS CLI; el emulador responde rápido.

Conviene conocer dos comportamientos, y ambos coinciden con AWS real:

  • No se puede escribir enseguida en una tabla de DynamoDB recién creada. Tras crearla, su estado es CREATING, y un put-item inmediato falla con ResourceNotFoundException. Ejecuta aws dynamodb wait table-exists, o usa un waiter en el código, antes de escribir. Aquí es donde más tropiezan las pruebas escritas por agentes.
  • Lambda revisa la política de confianza del rol. Nuestro primer intento usó un rol con el Statement vacío y falló con The role defined for the function cannot be assumed by Lambda. Al añadir sts:AssumeRole para lambda.amazonaws.com a la política de confianza, la función se creó.

Poner a Claude Code, Codex y Cursor a trabajar contra el emulador

Opción 1: instalar el skill oficial aws-emulator

Según la guía para agentes de código con IA, AWS CLI 2.35.0 o posterior instala el skill oficial con un solo comando. Después basta con decirle a tu agente «Install AWS Emulator and point my project at it»:

bash
aws agent-toolkit add-skill --skill-name aws-emulator --region us-east-1

El comando instala el skill para cada agente que detecta en la máquina y no necesita cuenta de AWS. Con AWS CLI 2.40.1, cada ejecución tardó unos 0,6 segundos y escribió en el directorio de cada agente encontrado:

  • Claude Code: ~/.claude/skills/aws-emulator/
  • Codex: ~/.agents/skills/aws-emulator/
  • Cursor: ~/.cursor/skills/aws-emulator/

Ojo: no ejecutes este comando en una shell con AWS_ENDPOINT_URL definido. Nuestro primer intento se hizo en una terminal que ya apuntaba al emulador y falló con UnknownService ... GetLatestSkillVersion, porque la petición de descarga del skill también fue al emulador. Una terminal limpia lo resolvió.

El skill solo contiene documentos, sin scripts: pasos de instalación para Linux, Docker y el modo embebido de Rust, cómo conectar cada SDK, una tabla de errores y una comprobación de «¿funcionará mi proyecto en el emulador?». Para saber cómo funcionan los skills en general, consulta Cómo usar Agent Skills.

Opción 2: definir las variables de entorno y darle una tarea al agente

Los agentes de Claude Code, Codex y Cursor ejecutan comandos en una terminal, así que lo más sencillo es definir las variables de la sección anterior en la terminal donde arrancas el agente. Los comandos aws y las pruebas con boto3 que ejecute el agente irán automáticamente al emulador, y aunque el agente se equivoque, no puede tocar una cuenta real. La terminal de Cursor lee las mismas variables; en esta prueba solo instalamos el skill para Cursor y no ejecutamos ninguna tarea en él.

Dimos la misma tarea a Claude Code y a Codex. El proyecto era un repositorio de Python vacío con boto3 1.44.1 y pytest 9.2.0 preinstalados en .venv:

text
The shell already points the AWS CLI and SDKs at a local AWS Emulator (AWS_ENDPOINT_URL=https://127.0.0.1:9297); never use a real AWS account.
1. Write notes.py with save_note(bucket, table, note_id, text): put the text in S3 at notes/<note_id>.txt and put an item {id, s3_key} in the DynamoDB table; and get_note(bucket, table, note_id) that returns the text by reading the item and then the S3 object.
2. Write tests/test_notes.py with pytest: create a uniquely named bucket and table (string key "id", PAY_PER_REQUEST, wait until the table exists) against the emulator, then test save/get round trip and that get_note of a missing id raises KeyError.
3. Run .venv/bin/pytest -q until it passes, then verify with the aws CLI that the object and item exist. Finish with a 3-line summary.
ClienteModeloTiempo realResultado
Claude Code 2.1.319 (claude -p)claude-opus-5-5unos 32,3 s, 5 turnosEscribió notes.py y tests/test_notes.py, 2 passed; confirmó el objeto notes/n1.txt y su ítem con el aws CLI
Codex CLI 0.167.0 (codex exec)gpt-6.1-solunos 80,9 sEscribió notes.py y tests/test_notes.py y añadió un pytest.ini; 2 passed in 3.36s, y luego confirmó el objeto y el ítem con un script

Los dos agentes usaron por su cuenta get_waiter("table_exists") y evitaron la trampa de «escribir justo después de crear». Después volvimos a ejecutar nosotros .venv/bin/pytest -q en el directorio de Claude Code y obtuvimos de nuevo 2 passed in 3.24s, y aws s3 ls mostraba los buckets notes-test-* creados por ambas ejecuciones. Lee el resumen del agente, pero fíate de tu propia ejecución.

Ejecutamos ambos en modo no interactivo: Claude Code con --permission-mode bypassPermissions y Codex con --dangerously-bypass-approvals-and-sandbox. Eso solo es adecuado para un directorio de pruebas desechable. En un repositorio real, bloquea los comandos peligrosos con hooks; consulta Configurar Agent Hooks en Claude Code / Codex / Cursor. Si quieres manejar Claude Code y Codex desde una sola interfaz, consulta T3 Code con Claude Code y Codex.

Conectar Claude Code y Codex a una API Key de AICodeWith

En las pruebas anteriores, ambos clientes usaron una API Key de AICodeWith. Si prefieres no iniciar sesión con una suscripción oficial, escribe la configuración global de cada CLI.

Para Claude Code, escribe ~/.claude/settings.json (guía completa: Configurar una API de terceros en Claude Code):

json
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.aicodewith.ai",
    "ANTHROPIC_AUTH_TOKEN": "tu API Key de AICodeWith"
  }
}

Para Codex, escribe ~/.codex/config.toml (descarga e instalación: Descargar Codex; referencia de campos: Guía de config.toml de Codex):

toml
model_provider = "aicodewith"
model = "gpt-6.1-sol"

[model_providers.aicodewith]
name = "aicodewith"
base_url = "https://api.aicodewith.ai/chatgpt/v1"
wire_api = "responses"
experimental_bearer_token = "tu API Key de AICodeWith"

Comprueba primero cada uno por separado: claude -p "Reply with exactly: pong" y codex exec --skip-git-repo-check "Reply with exactly: pong". En nuestra prueba ambos devolvieron pong, en unos 4,3 segundos Claude Code y 4,8 segundos Codex.

No mezcles los dos juegos de credenciales. La Key de AICodeWith solo sirve para que el agente llame al modelo. En el lado de AWS, el emulador usa claves temporales que empiezan por EMULATOR... y que genera en cada arranque; no tienen nada que ver con tu Key del modelo.

Create API Key →

Llevarlo a CI

Según la documentación, el emulador guarda el estado solo en memoria, y /__admin/health existe para que scripts y contenedores esperen a que esté listo. Aquí tienes un ejemplo de GitHub Actions; los comandos de instalación y arranque son los que ejecutamos arriba en Debian:

yaml
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install and start AWS Emulator
        run: |
          curl -fsSLo aws-emulator.deb https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator_amd64.deb
          sudo apt-get install -y ./aws-emulator.deb
          aws-emulator -t off &
          until curl -sf --cacert ~/.aws/emulator/9297/ca.pem https://127.0.0.1:9297/__admin/health; do sleep 0.2; done
      - name: Run tests against the emulator
        run: |
          export AWS_ENDPOINT_URL=https://127.0.0.1:9297
          export AWS_SHARED_CREDENTIALS_FILE=~/.aws/emulator/9297/emulator_credentials
          export AWS_CONFIG_FILE=~/.aws/emulator/9297/config
          export AWS_EC2_METADATA_DISABLED=true AWS_DISABLE_HOST_PREFIX_INJECTION=true
          export AWS_REGION=us-east-1 AWS_DEFAULT_REGION=us-east-1
          pytest -q

No pongas credenciales reales de AWS en el entorno de los jobs de CI; AWS también lo recomienda.

Límites: lo que no puede hacer

Según el blog AWS News y la documentación de fidelidad:

  • No evalúa políticas de IAM. Una petición que AWS rechazaría puede funcionar en el emulador, así que no lo uses para probar seguridad.
  • Una cuenta, una Región. No hay comportamiento entre cuentas ni entre Regiones.
  • Las operaciones aún no implementadas devuelven HTTP 501 (`NotImplemented`). Tu prueba falla al momento en lugar de pasar en silencio.
  • La fidelidad varía según el servicio. Las API del plano de control (crear, describir y borrar recursos) son las más cercanas a AWS; las API del plano de datos y las herramientas IaC como CloudFormation, Terraform y el CDK varían más según el servicio. Las puntuaciones de fidelidad por servicio se publican con cada versión en GitHub Releases, y las pruebas son públicas en el repositorio aws-emulator-evaluation-suite.
  • Reiniciar lo borra todo. Al pararlo y volver a arrancarlo, los buckets y tablas anteriores habían desaparecido, y la Access Key de emulator_credentials cambió de EMULATORC3... a EMULATOR1D.... Vuelve a leer el archivo de credenciales tras cada reinicio.

Errores comunes y soluciones

Error / síntomaCausaSolución
AccessDenied: Sign the request with the emulator credentialsFirmado con otras claves, por ejemplo claves reales de AWS en variables de entorno (lo vimos con una clave falsa)unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE y apuntar AWS_SHARED_CREDENTIALS_FILE al emulator_credentials de esta ejecución
ResourceNotFoundException justo después de crear una tabla de DynamoDBLa tabla sigue en CREATING (lo vimos)aws dynamodb wait table-exists, o un waiter en el código
UnknownService: could not resolve a target serviceUna petición que no era para el emulador fue a él, por ejemplo instalar el skill en una terminal con AWS_ENDPOINT_URL definido (lo vimos)Ejecutarlo en una terminal sin AWS_ENDPOINT_URL
SSL: CERTIFICATE_VERIFY_FAILEDEl cliente no confía en el ca.pem de esta ejecuciónDefinir AWS_CONFIG_FILE; en Node NODE_EXTRA_CA_CERTS, en Java truststore.p12; nunca desactivar la verificación de certificados
sts get-caller-identity muestra una cuenta realEse comando se ejecutó sin AWS_ENDPOINT_URL y fue a AWSEjecutarlo en la terminal o el script con las variables definidas
Address already in useEl puerto está ocupadoUsar otro puerto, por ejemplo aws-emulator -p 9300, y cambiarlo también en las variables
NotImplemented / HTTP 501La versión instalada aún no implementa esa operaciónActualizar a la última versión y revisar la puntuación de fidelidad del servicio en Releases

FAQ

¿Las API de AWS Emulator son las mismas que las de AWS real?

Según AWS, está construido con los mismos modelos de API Smithy que usan los SDK de AWS, así que las peticiones y los errores tienen la misma forma que en AWS. Que el comportamiento coincida depende de la puntuación de fidelidad de cada servicio. El estado CREATING de DynamoDB y la revisión de la política de confianza de Lambda que encontramos coincidieron con AWS.

¿Se puede instalar directamente en macOS?

No; se usa Docker. AWS solo publica paquetes para Linux; en macOS y Windows construyes una imagen con el Dockerfile oficial.

¿Sirve para producción o para pruebas de seguridad?

No. AWS indica que es solo para desarrollar y probar. No evalúa políticas de IAM ni está pensado para cargas de producción.

¿Podría el agente cambiar por error mis recursos reales de AWS?

Mientras la terminal donde arrancas el agente tenga AWS_ENDPOINT_URL definido y las credenciales reales eliminadas, las peticiones solo van a tu máquina. Además, el emulador solo acepta peticiones firmadas con las claves EMULATOR... que él mismo generó. Antes de empezar, ejecuta una vez aws sts get-caller-identity y comprueba que la cuenta es 000000000000.

¿Qué conviene más aquí: Claude Code, Codex o Cursor?

Los tres sirven: cada uno puede instalar el skill oficial y hereda las variables de entorno de su terminal. En esta prueba, Claude Code y Codex completaron la misma tarea a la primera. Elige el que ya uses.

Create API Key →

Fuentes

相关文章

Qué es el UI SDK y cómo se usa? La biblioteca de comportamientos de Vercel y shadcn para agentes, instalada y probada en Claude Code / Codex / Cursor (0.1.0-beta.1)

Qué es el UI SDK y cómo se usa? La biblioteca de comportamientos de Vercel y shadcn para agentes, instalada y probada en Claude Code / Codex / Cursor (0.1.0-beta.1)

El UI SDK es la biblioteca de comportamientos de Vercel para agentes, publicada el 12 de noviembre de 2026 como 0.1.0-beta.1. Los comportamientos viven en el paquete independiente del framework @ui-sdk/core y los renderizan adaptadores para React, Vue, Svelte, Solid y Web Components. Esta guía sigue la documentación oficial sobre qué es, cómo instalarlo y cómo añadir el skill para Claude Code, Codex y Cursor, y registra los comandos, tiempos y salidas de nuestra máquina de prueba.

¿Qué es T3 Code y cómo se instala? Conectar Claude Code y Codex, usar una API Key de terceros y resolver errores comunes (probado en 0.1.9)

¿Qué es T3 Code y cómo se instala? Conectar Claude Code y Codex, usar una API Key de terceros y resolver errores comunes (probado en 0.1.9)

T3 Code es la consola de código abierto de pingdotgg para manejar agentes de programación. No trae modelo propio: controla los CLI de Claude Code, Codex, Cursor y otros que ya tienes instalados. Probamos T3 Code 0.1.9 en Linux. Esta guía cubre los comandos de instalación, cómo conectar Claude Code y Codex a una API Key de AICodeWith para que T3 Code los controle, una ejecución completa de ambos agentes con el comando t3 thread y los errores que encontramos, con su solución.

Claude Code / Codex / Cursor Agent Hooks: configuración comparada, PreToolUse, script mínimo y prueba de fail-open

Claude Code / Codex / Cursor Agent Hooks: configuración comparada, PreToolUse, script mínimo y prueba de fail-open

Las instrucciones, AGENTS.md y los skills son sugerencias que el modelo puede ignorar; los hooks son scripts deterministas que el harness ejecuta en momentos fijos. Este artículo compara las rutas de configuración, nombres de eventos, exit 2 / deny, fail-open y fail-closed de Claude Code, Codex y Cursor para PreToolUse (o su equivalente), e incluye un script mínimo de intercepción probado en Claude Code.