> Nivel 0 de Agent Harness Patterns, un recorrido de patrones sobre cómo funcionan los agentes de IA. Versión web: https://harnesspatterns.dev/es/patterns/your-toolkit · Todos los patrones (en inglés): https://harnesspatterns.dev/llms.txt

# Tu caja de herramientas

Antes de cualquier agente, cuatro piezas. Un modelo que solo lee y escribe texto, un system prompt que le dice quién ser, una lista de mensajes que tu código reenvía cada vez, y herramientas que puede pedir. Todo lo que viene después en este mapa se construye con ellas.

## Las cuatro piezas

- El modelo `model`
   El personaje
   Lee texto, escribe texto. Sabe mucho por su entrenamiento, pero nada de tu app, de tu usuario ni del día de hoy.
- El system prompt `system`
   Equipo
   Instrucciones que van al principio de cada pedido: quién es, sus reglas, su tono y los datos que no puede saber por sí mismo.
- Los mensajes `messages[]`
   Bolsa
   La conversación hasta ahora. Tu código guarda esta lista y la envía completa en cada llamada.
- Las herramientas `tools`
   Habilidades
   Tarjetas que describen funciones que el modelo puede pedir. Solo puede pedirlas: quien las ejecuta es tu código.

## El modelo no recuerda nada

Esto es lo que sorprende a la gente. Un modelo no tiene memoria entre llamadas. Cada pedido empieza de cero, y lo único que sabe es lo que viene dentro de ese pedido: el system prompt, los mensajes y la lista de herramientas.

En la animación, la segunda pregunta llega sola y el Oráculo pregunta "¿qué ciudad?", aunque se lo dijeron hace un momento. Solo "recuerda" cuando tu código vuelve a enviar los mensajes anteriores. Las apps de chat parecen recordar porque reenvían la conversación completa cada vez.

De ahí salen dos cosas. El historial es tuyo: lo guardas, lo recortas y lo almacenas tú. Y cada mensaje que conservas se vuelve a enviar en cada llamada, así que una conversación larga cuesta más cada vez.

## Texto, o un pedido

Con herramientas en su lista, una respuesta puede ser una de dos cosas: texto para el usuario, o un pedido para llamar a una herramienta con ciertos datos de entrada. El modelo nunca ejecuta nada. Escribe `get_forecast(city, date)` y se detiene; ejecutarlo es trabajo de tu código.

Fíjate en la fecha: el modelo convirtió "mañana" en `2026-09-26` porque el system prompt le dijo qué día es hoy. Los datos que no puede saber por sí mismo van ahí.

## El código

**Con astorlm:** Un agente de astorlm tiene las mismas cuatro piezas. Guarda el historial por ti entre llamadas a `run()`, y cuando el modelo pide una herramienta, la ejecuta y le devuelve el resultado. Ese bucle es el nivel 2.

**Desde cero:** Las cuatro piezas y un único pedido, todavía sin bucle. Completa el bloque `LLM` con tu propio endpoint, modelo y clave.

**Con astorlm**

```ts
import { OpenAIProvider, createLocalAgent, tool } from 'astorlm'
import { z } from 'zod'

// A tool: the card the model reads (name, description, schema) plus your code behind it.
const getForecast = tool({
  name: 'get_forecast',
  description: 'Daily forecast for one city: rain chance and min/max temp. date is YYYY-MM-DD.',
  schema: z.object({ city: z.string(), date: z.string() }),
  execute: async ({ city, date }) => forecastLine(city, date), // your code; the model never sees it
})

const agent = await createLocalAgent({
  // Any OpenAI-compatible endpoint: OpenAI, Ollama, LM Studio, vLLM, a proxy…
  provider: new OpenAIProvider({
    baseURL: 'http://localhost:11434/v1', // e.g. Ollama's default address
    model: 'your-model', // e.g. 'llama3.1', 'gpt-4o-mini'
    apiKey: 'YOUR_API_KEY', // local servers usually ignore it
  }),
  systemPrompt: 'You are Nimbus, a weather assistant. Today is 2026-09-25. Answer in one short line.',
  contextFiles: [], // by default astorlm also appends AGENTS.md and CLAUDE.md from the working folder
  tools: [getForecast],
})

// The agent keeps the history for you, so the second run knows about the first.
await agent.run('I’m in Buenos Aires.')
await agent.run('Will it rain tomorrow?') // asks for get_forecast(Buenos Aires, 2026-09-26), runs it, answers
console.log(agent.getMessages().length) // every message so far, resent on every call
```

**TypeScript**

```ts
// The four pieces, with no agent yet: one request in, one reply out. Plain fetch, no SDK.

// Any OpenAI-compatible endpoint: OpenAI, Ollama, LM Studio, vLLM, a proxy…
const LLM = {
  baseURL: 'http://localhost:11434/v1', // e.g. Ollama's default address
  model: 'your-model', // e.g. 'llama3.1', 'gpt-4o-mini'
  apiKey: 'YOUR_API_KEY', // local servers usually ignore it
}

type ToolCall = { id: string; function: { name: string; arguments: string } }
type Message =
  | { role: 'user'; content: string }
  | { role: 'assistant'; content: string | null; tool_calls?: ToolCall[] }

// 1. The system prompt: who it is, its rules, and facts it can't know on its own.
const system = 'You are Nimbus, a weather assistant. Today is 2026-09-25. Answer in one short line.'

// 2. The history. The model remembers nothing between calls: this array IS its memory.
const messages: Message[] = []

// 3. A tool, as the model sees it: a name, a description and its inputs. Never the code.
const tools = [
  {
    type: 'function',
    function: {
      name: 'get_forecast',
      description: 'Daily forecast for one city: rain chance and min/max temp. date is YYYY-MM-DD.',
      parameters: {
        type: 'object',
        properties: { city: { type: 'string' }, date: { type: 'string' } },
        required: ['city', 'date'],
      },
    },
  },
]

// 4. The model: every call sends ALL of the above, and gets back one message.
async function ask(text: string): Promise<Message> {
  messages.push({ role: 'user', content: text })
  const res = await fetch(`${LLM.baseURL}/chat/completions`, {
    method: 'POST',
    headers: { 'content-type': 'application/json', authorization: `Bearer ${LLM.apiKey}` },
    body: JSON.stringify({ model: LLM.model, messages: [{ role: 'system', content: system }, ...messages], tools }),
  })
  const reply: Message = (await res.json()).choices[0].message
  messages.push(reply) // keep it, or the next call won't know it happened
  return reply
}

await ask('I’m in Buenos Aires.') // "Got it! How can I help?"
const reply = await ask('Will it rain tomorrow?')
// The reply is either text (reply.content) or a tool request (reply.tool_calls):
// get_forecast({ city: "Buenos Aires", date: "2026-09-26" })
// Running it and sending the result back, in a loop, is level 2.
```

**Python**

```python
# The four pieces, with no agent yet: one request in, one reply out. Standard library only, no SDK.
import json
import urllib.request

# Any OpenAI-compatible endpoint: OpenAI, Ollama, LM Studio, vLLM, a proxy...
LLM = {
    "base_url": "http://localhost:11434/v1",  # e.g. Ollama's default address
    "model": "your-model",  # e.g. "llama3.1", "gpt-4o-mini"
    "api_key": "YOUR_API_KEY",  # local servers usually ignore it
}

# 1. The system prompt: who it is, its rules, and facts it can't know on its own.
SYSTEM = "You are Nimbus, a weather assistant. Today is 2026-09-25. Answer in one short line."

# 2. The history. The model remembers nothing between calls: this list IS its memory.
messages = []

# 3. A tool, as the model sees it: a name, a description and its inputs. Never the code.
TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "get_forecast",
            "description": "Daily forecast for one city: rain chance and min/max temp. date is YYYY-MM-DD.",
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string"}, "date": {"type": "string"}},
                "required": ["city", "date"],
            },
        },
    }
]

# 4. The model: every call sends ALL of the above, and gets back one message.
def ask(text):
    messages.append({"role": "user", "content": text})
    request = urllib.request.Request(
        f"{LLM['base_url']}/chat/completions",
        data=json.dumps({
            "model": LLM["model"],
            "messages": [{"role": "system", "content": SYSTEM}, *messages],
            "tools": TOOLS,
        }).encode(),
        headers={"Content-Type": "application/json", "Authorization": f"Bearer {LLM['api_key']}"},
    )
    with urllib.request.urlopen(request) as response:
        reply = json.load(response)["choices"][0]["message"]
    messages.append(reply)  # keep it, or the next call won't know it happened
    return reply

ask("I'm in Buenos Aires.")  # "Got it! How can I help?"
reply = ask("Will it rain tomorrow?")
# The reply is either text (reply["content"]) or a tool request (reply["tool_calls"]):
# get_forecast(city="Buenos Aires", date="2026-09-26")
# Running it and sending the result back, in a loop, is level 2.
```

## Qué vigilar

- **Mantén el system prompt corto y específico.** Viaja en cada llamada. Rol, reglas, tono y los datos que el modelo necesita; no un manual.
- **Decide qué conserva el historial.** Reenviarlo todo para siempre se vuelve lento y caro, y al final no entra. Recortarlo y resumirlo es un patrón en sí mismo.
- **Un modelo sin herramientas igual responde.** Pregúntale por datos en vivo y va a adivinar, con total fluidez. Si la respuesta depende de algo que no puede ver, dale una herramienta.

## Patrones relacionados

- [1 · ¿Qué es un agente?](https://harnesspatterns.dev/es/patterns/what-is-an-agent.md)
- [2 · El bucle del agente](https://harnesspatterns.dev/es/patterns/agent-loop.md)
- [3 · Diseñar una herramienta](https://harnesspatterns.dev/es/patterns/designing-a-tool.md)
- [7 · La mochila se llena](https://harnesspatterns.dev/es/patterns/compaction.md)