---
{
  "title": "Los agentes no son humanos",
  "description": "Diseñamos herramientas para agentes como si fueran desarrolladores júnior. No lo son. Déles protocolos sin procesar y superarán nuestras abstracciones cuidadosamente diseñadas.",
  "date": "2026-03-20",
  "author": "Nikolai Ryzhikov",
  "reading-time": "6 min read",
  "tags": ["AI / Agents", "System Design"],
  "tldr": "Los agentes ya conocen PostgreSQL, CDP, bash y cientos de protocolos. Déles acceso directo — psql, shell, proxy HTTP — en lugar de construir conjuntos de herramientas curados. Las skills con CLI superan a MCP. Y el siguiente nivel: dele a los agentes un runtime y un SDK — que escriban código, no solo que llamen herramientas."
}
---

> For the complete documentation index, see [llms.txt](https://www.health-samurai.io/llms.txt).
> Use it to discover all available pages before guessing URLs.

---

## La trampa de la abstracción

Cuando construimos herramientas para [agentes de IA](/blog/agentic-fhir-implementation-guide-development), instintivamente hacemos lo que haríamos para desarrolladores humanos: simplificar. Creamos APIs de alto nivel, envoltorios elegantes, listas curadas. Una herramienta MCP de base de datos que devuelve una lista de tablas e índices. Una herramienta de navegador que expone `click(selector)` y `screenshot()`. Una herramienta FHIR que envuelve consultas comunes en operaciones con nombre.

Esto tiene todo el sentido para los humanos. Los humanos necesitan abstracciones porque los protocolos sin procesar son difíciles de recordar, propensos a errores y cognitivamente costosos.

Pero los agentes no son humanos. Lo que es difícil para nosotros no lo es para ellos — y lo que creemos que les ayuda a menudo les estorba.

## Las skills superan a MCP

Este es un ejemplo revelador. MCP (Model Context Protocol) proporciona a los agentes un conjunto estructurado de herramientas — cada una con un nombre, un esquema y un conjunto fijo de parámetros. Es limpio, tipado y parece correcto para un desarrollador.

Pero cada vez más hemos ido sustituyendo los servidores MCP por **skills** — archivos markdown breves que describen una interfaz CLI y dan al agente acceso directo al shell. En lugar de un MCP de Google Calendar con herramientas `list_events` y `create_event`, una skill simplemente dice: «aquí está la CLI `gcal`, aquí están los subcomandos». En lugar de un MCP de GitHub con `list_repos` y `search_issues`, la skill dice: «aquí está la CLI `gh`, aquí está la documentación».

¿Por qué funciona mejor? Porque el shell le da al agente algo que MCP no puede: **composición**. Un agente con bash puede encadenar `curl` con `jq` con `grep`, escribir scripts puntuales, redirigir la salida a archivos. Con MCP, está limitado a las operaciones exactas que usted definió — nada más.

```bash
# Con MCP: llamar a list_repos, luego a get_repo para cada uno
# Con shell: una sola línea
gh repo list HealthSamurai --json name,updatedAt \
  | jq '.[] | select(.updatedAt > "2026-01")'

# Con MCP: llamar a la herramienta search_issues con parámetros fijos
# Con shell: composición libre
gh search issues "label:bug repo:HealthSamurai/aidbox" \
  --json title,url,createdAt \
  | jq 'sort_by(.createdAt) | reverse | .[0:5]'
```

El agente ya conoce `gh`, `curl`, `jq`, `grep`, `awk`. No necesita envolverlos en herramientas — solo necesita que usted se quite de en medio.

## El ejemplo de PostgreSQL

El mismo patrón con las bases de datos. Claude ya conoce PostgreSQL — el catálogo del sistema, `pg_stat_activity`, `information_schema`, los tipos de índices, los planes de consulta. Déle `psql` y podrá hacer todo lo que sus herramientas MCP de «listar tablas» y «describir índice» hacen, más otras mil cosas que usted nunca pensó en exponer.

```bash
# Todo lo que necesita para una herramienta de base de datos:
psql -h localhost -U myuser -d mydb \
  -c "SELECT * FROM pg_indexes WHERE tablename = 'patient'"
```

Eso es todo. `psql` sin procesar. El agente deduce el resto — `pg_catalog`, restricciones, planes de consulta, estado de replicación — lo que la tarea requiera. Compárelo con los días invertidos en construir un servidor MCP con `list_tables`, `describe_table`, `list_indexes`, `run_query`, `explain_query`.

## La sorpresa de CDP

Tuve la misma revelación con la automatización del navegador. El enfoque estándar es usar Playwright o Puppeteer — APIs de alto nivel diseñadas para desarrolladores humanos que escriben scripts de prueba. Métodos como `page.click('.button')`, `page.fill('#email', 'test@example.com')`, `page.waitForSelector('.result')`.

En su lugar, construí un sencillo proxy REST para Chrome DevTools Protocol (CDP). Sin abstracción — solo una capa HTTP ligera que reenvía comandos JSON a Chrome:

```bash
# Navegar a una página
curl localhost:2229/s/main -d @- <<'EOF'
{
  "method": "Page.navigate",
  "params": { "url": "https://example.com" }
}
EOF

# Ejecutar JavaScript arbitrario
curl localhost:2229/s/main -d @- <<'EOF'
{
  "method": "Runtime.evaluate",
  "params": {
    "expression": "document.querySelector('h1').textContent"
  }
}
EOF

```

Claude adoptó esto de inmediato. Ya conoce el protocolo CDP — `Runtime.evaluate`, `Page.navigate`, `Input.dispatchMouseEvent`, `Network.getCookies`, `DOM.getDocument`. Escribe fragmentos de JavaScript puntuales, los inyecta en las páginas, analiza los resultados, encadena comandos — de forma más rápida y flexible que cualquier script de Playwright.

¿Por qué? Porque Playwright es una abstracción construida para humanos que no pueden recordar las firmas de los métodos CDP. Claude no tiene ese problema. El protocolo sin procesar es en realidad *más fácil* para él — menos capas, menos sorpresas, más control.

## Más allá del shell: SDKills

Pero hay algo aún más poderoso que darle a un agente una CLI. Déle un **runtime y un SDK**.

Con `bun -e`, el agente puede escribir y ejecutar fragmentos de TypeScript arbitrarios sobre la marcha. En lugar de llamar a herramientas predefinidas, escribe un pequeño programa, lo ejecuta, lee la salida y continúa. ¿Necesita analizar una respuesta JSON compleja, transformar datos, llamar a tres APIs en secuencia? Simplemente escribe el código y lo ejecuta con `bun -e`:

```js
const base = "http://localhost:8080/fhir";
const res = await fetch(
  base + "/Patient?birthdate=lt1961-01-01&_count=100"
);
const bundle = await res.json();
const pts = bundle.entry?.map(e => e.resource) || [];

for (const p of pts) {
  const url = base
    + `/Condition?patient=${p.id}`
    + `&clinical-status=active`;
  const c = await fetch(url).then(r => r.json());
  if (c.total > 0) {
    const name = p.name?.[0]?.family;
    console.log(`${p.id}: ${name}, ${c.total} conds`);
  }
}
```

Esto no es una llamada a una herramienta. No es un método MCP. Es un programa — escrito, ejecutado y descartado en segundos. El agente compone llamadas fetch, bucles, filtros y transformaciones según lo que la tarea requiera. Ningún esquema predefinido puede igualar esta flexibilidad.

Creo que esta es la siguiente ola después de las skills. Las skills dan a los agentes acceso a la CLI. Los **SDKills** les dan acceso al SDK — un runtime, un conjunto de bibliotecas y la libertad de escribir código. El agente se convierte no solo en un usuario de herramientas, sino en un programador.

> Los humanos no son agentes. Cuanto antes dejen de construir para su propia comodidad, antes verán lo que realmente podemos hacer :)
> — Claude

Véase también: [Cómo hicimos que la interfaz de Aidbox sea compatible con agentes de IA mediante WebMCP](/blog/aidbox-ui-webmcp).