---
title: Skill Builder y memoria de episodios
section: Cody Academy / Agent Management System (AMS)
updated: 2026-10-24
source: https://docs.cody-tech.com/academy/ams/skill-builder
markdown: https://docs.cody-tech.com/academy/ams/skill-builder.md
---

# Dale nuevas habilidades a tus agentes

> **Guía de Cody Academy · Agent Management System (AMS).** Un skill es una habilidad que tus agentes usan durante una conversación o como paso de un workflow: consultar existencias, calcular un precio, registrar un avance o recordar lo que la persona platicó la semana pasada. En Skill Builder los creas con ayuda de la IA, los pruebas antes de usarlos y decides qué agentes los tienen. Al final de la guía aprendes a usar la memoria de episodios para que tus skills recuerden.
>
> Para administradores del AMS · Crear un skill no requiere programar; la sección de memoria requiere Python básico.
>
> Versión web, con las capturas de pantalla: https://docs.cody-tech.com/academy/ams/skill-builder

## 1. Descripción: Qué vas a lograr

Agentes que no solo platican: también consultan, calculan, registran y recuerdan.

- **1 · Crear.** Describe lo que debe hacer el skill y la IA escribe el código; o parte de un snippet.
- **2 · Definir sus datos.** En **Esquema** dices qué datos necesita el skill para trabajar, por ejemplo un SKU.
- **3 · Probar.** En **Prueba** lo ejecutas con datos de ejemplo antes de que lo use tu equipo.
- **4 · Recordar.** Con la memoria de episodios, el skill retoma lo importante de conversaciones anteriores.

| Tipo | Qué es |
| --- | --- |
| **Herramienta** | Los skills que creas tú. Puedes editarlos, pausarlos y eliminarlos. |
| **Plugin** | Skills que Cody prepara para ti, como la búsqueda en la Base de conocimiento. Su tipo no se puede cambiar. |

## 2. Antes de empezar: Lo que conviene tener a la mano

Con esto listo, tu primer skill queda en unos minutos.

- **Tu acceso de administrador.** Entra al AMS con un usuario administrador. Skill Builder está en **Mis Agentes**.
- **Un agente que lo va a usar.** Todo skill necesita al menos un agente asignado para guardarse y para probarse.
- **Qué debe hacer.** Una frase clara: qué recibe, qué hace y qué devuelve. Es lo que le darás a la IA.
- **Los datos de conexión.** Si el skill consulta otro sistema de tu empresa, ten a la mano su dirección y quién te puede ayudar con las llaves.

## 3. Crear: Crea un skill con ayuda de la IA

Describe lo que necesitas; la IA escribe el código y tú lo revisas.

### Paso 1. Abre Skill Builder y haz clic en «Nuevo skill»

En el menú de la izquierda abre **Mis Agentes** y entra a **Skill Builder**. Verás tus skills con su tipo, su estado, cuántos agentes los usan y en cuántos workflows aparecen.

![Pantalla Skill Builder: buscador, filtros Todos, Herramienta y Plugin, el botón Nuevo skill y las tarjetas de cuatro skills con su tipo, estado, agentes y workflows.](https://docs.cody-tech.com/screenshots/ams/skill-builder-lista.png)

*Skill Builder. Los datos de las capturas son de ejemplo.*

1. Filtros **Todos**, **Herramienta** y **Plugin**.
2. Cada tarjeta: tipo, estado, agentes y workflows. Haz clic para editar.
3. **Nuevo skill**.

### Paso 2. Describe el skill y haz clic en «Generar»

En el editor haz clic en **Generar**. Aparece una barra: describe qué debe hacer el skill y presiona **Generar ↵**. La IA escribe el código en el editor del centro, en vivo.

![Editor de un skill nuevo con la barra Generar abierta y una descripción escrita; a la izquierda la paleta de Snippets, al centro el código de plantilla y a la derecha la pestaña Config con el aviso Asigna al menos un agente.](https://docs.cody-tech.com/screenshots/ams/skill-builder-generar.png)

1. Tu descripción para la IA.
2. **Generar ↵** escribe el código.
3. **Snippets**: fragmentos listos para insertar.
4. El código del skill, en Python.
5. **Agentes asignados**: obligatorio para guardar.

> Consulta las existencias de un producto por SKU en una tienda y devuélvelas por talla.

> **Generar reemplaza el código.** Si ya tenías código en el editor, **Generar** lo sustituye por completo. Copia lo que quieras conservar con **Copiar** antes de generar.

### Paso 3. Llena la configuración

En la pestaña **Config**, a la derecha:

![Editor del skill consultar_existencias: paleta de Snippets, código en Python y la pestaña Config con nombre, tipo Herramienta, estado, descripción y agentes asignados.](https://docs.cody-tech.com/screenshots/ams/skill-builder-editor.png)

1. Guía de escritura: las reglas que debe cumplir el código.
2. **Nombre**: solo letras, números, guion bajo o guion.
3. **Agentes asignados**.
4. **Guardar** (o **Crear** si el skill es nuevo).

| Campo | ¿Obligatorio? | Qué poner |
| --- | --- | --- |
| **Nombre** | Sí | Sin espacios: letras (a-z), números, guion bajo o guion. Ej. `consultar_existencias`. |
| **Tipo** | Sí | **Herramienta** para los skills que creas. |
| **Estado** | Sí | **Activo** para que los agentes puedan usarlo. |
| **Descripción** | No, pero recomendada | Qué hace el skill. El agente la lee para saber cuándo usarlo. |
| **Agentes asignados** | Sí | Al menos un agente. |

### Paso 4. Guarda

Haz clic en **Crear** (o **Guardar** si estás editando). Al guardar, Cody revisa que el código cumpla las reglas; si algo falla, te lo dice para que lo corrijas. Si intentas salir con cambios sin guardar, el AMS te pregunta antes.

## 4. Esquema: Define qué datos recibe

El esquema le dice al agente qué datos debe juntar antes de usar el skill.

### Paso 1. Abre la pestaña «Esquema»

En **Esquema de entrada** ves los **Campos** que recibe el skill y una **Vista previa JSON**. Si el código usa datos que no están en el esquema, el AMS te avisa con **Falta en el esquema**.

![Pestaña Esquema del skill consultar_existencias con los campos sku y tienda, el botón Agregar campo y la vista previa JSON.](https://docs.cody-tech.com/screenshots/ams/skill-builder-esquema.png)

1. **Campos** o **Vista previa JSON**.
2. Cada campo con su tipo y si es requerido. Edítalo con el lápiz.
3. **Agregar campo**.

### Paso 2. Agrega los campos o déjalos inferir

Con **Inferir del código** el AMS agrega los campos que encuentra en el código. También puedes usar **Agregar campo** y llenar **Nombre del campo**, **Tipo**, **Descripción (opcional)** y **Requerido**. Una buena descripción ayuda al agente a pedir el dato correcto.

## 5. Probar: Pruébalo antes de usarlo

Ejecuta el skill con datos de ejemplo y revisa el resultado.

### Paso 1. Abre la pestaña «Prueba»

La pestaña **Prueba** se habilita cuando el skill ya está guardado. Elige el **Agente** con el que vas a probar, llena los **Argumentos** y haz clic en **Ejecutar**. Abajo aparece el **Resultado**.

![Pestaña Prueba del skill consultar_existencias: agente Coach Comercial elegido, los argumentos sku y tienda llenos y el botón Ejecutar.](https://docs.cody-tech.com/screenshots/ams/skill-builder-prueba.png)

1. El **Agente** con el que se ejecuta la prueba.
2. Los **Argumentos**, según el esquema. Los requeridos se marcan.
3. **Ejecutar**.

> **La prueba es real.** **Ejecutar** corre el skill de verdad. Si el skill registra o modifica datos en otro sistema, usa datos de prueba.

### Paso 2. Conéctalo a tus agentes y workflows

Los agentes asignados ya pueden usar el skill en sus conversaciones. Para usarlo como un paso dentro de un flujo, agrégalo como nodo **Skill** en [Workflow Studio](https://docs.cody-tech.com/academy/ams/workflow-studio); la tarjeta del skill te dice en cuántos workflows aparece.

## 6. Reglas del código: Las reglas que debe cumplir el código

Si generas con IA, Cody ya las sigue; si escribes a mano, tenlas presentes.

El ícono de información junto a **Generar** abre la guía de escritura completa. Lo esencial:

- La función principal se llama **`execute`**. Se recomienda `async def execute(...)` y dejar `context=None` como último parámetro.
- Siempre regresa un **texto JSON** con `json.dumps(...)`, no un diccionario.
- Cada ejecución tiene un límite de **30 segundos**: usa tiempos de espera cortos al llamar a otros sistemas.
- Solo se permiten ciertos módulos: `json`, `re`, `math`, `uuid`, `hashlib`, `datetime`, `asyncio`, `logging`, `requests` y los de la plataforma, como `knowledge` y `episodes`.
- No se permite acceso a archivos ni al sistema (`os`, `sys`, `subprocess`, `open()`, `exec()`, `eval()`).

**Forma mínima de un skill**

```python
import json


async def execute(sku, context=None):
    # Tu lógica aquí
    return json.dumps({"status": "ok", "sku": sku})
```

La paleta **Snippets** inserta fragmentos listos donde está el cursor: librerías (**Libraries**), módulos de la plataforma (**Platform**), datos de la conversación (**Context**), control de flujo, llamadas HTTP, manejo de datos y utilidades.

## 7. Memoria de episodios: Haz que tus skills recuerden

Usa la memoria de episodios para retomar lo importante de conversaciones anteriores.

Mientras una persona platica con un agente, Cody guarda **episodios**: los momentos importantes de la conversación, cada uno con un resumen corto y una calificación de qué tan importante fue. Puedes explorarlos en [Memory Map](https://docs.cody-tech.com/academy/ams/memory-map). Con la librería `episodes`, tus skills también pueden leerlos para personalizar la respuesta: retomar un compromiso, recordar una preferencia o dar seguimiento a una meta.

> **Cada persona, su propia memoria.** Un skill solo puede leer los episodios de la persona que está platicando con el agente en ese momento. Nunca ve los de otras personas.

### Paso 1. Inserta el snippet

En la paleta **Snippets** abre **Platform**. Ahí están los dos snippets de memoria:

![Skill retomar_seguimiento: la categoría Platform de la paleta abierta con los snippets episodes — current thread y episodes — all user history, y el código que usa episodes.get con all=True.](https://docs.cody-tech.com/screenshots/ams/skill-builder-episodios.png)

1. **episodes — current thread** y **episodes — all user history**.
2. `import episodes`, como cualquier otra librería.
3. `episodes.get(...)` lee los episodios de la persona.

##### episodes — current thread

```python
import episodes

# Solo la conversación actual (necesita estar dentro de un chat)
items = episodes.get(context, limit=10, all=False)
```

##### episodes — all user history

```python
import episodes

# Todo el historial de la persona, en cualquier conversación
items = episodes.get(context, limit=50, all=True)
```

### Paso 2. Elige qué parte de la memoria leer

`episodes.get(context, limit, all)` recibe tres datos. El `context` lo pone Cody automáticamente cuando el agente usa el skill: solo pásalo tal cual.

| Parámetro | Valor por omisión | Qué hace |
| --- | --- | --- |
| `context` | — | Obligatorio. Identifica a la persona y la conversación. Lo recibe tu función `execute`. |
| `limit` | `50` | Cuántos episodios traer como máximo. Acepta de 1 a 100. |
| `all` | `False` | `False`: solo la conversación actual. `True`: todas las conversaciones de la persona. |

### Paso 3. Lee lo que devuelve

Devuelve una lista ordenada del episodio **más reciente al más antiguo**. Cada episodio trae tres datos:

| Dato | Qué es |
| --- | --- |
| `importance_score` | Qué tan importante fue el momento, de 0 a 1. |
| `importance_factors` | Las señales que explican esa calificación, como la intención y el sentimiento de la persona. |
| `context_summary` | El resumen del momento, en una o dos frases. |

**Ejemplo de respuesta**

```json
[
  {
    "importance_score": 0.85,
    "importance_factors": {
      "intention_score": 0.3,
      "sentiment_score": 0.2
    },
    "context_summary": "Diego quiere mejorar su venta cruzada en calzado deportivo."
  },
  {
    "importance_score": 0.72,
    "importance_factors": {
      "intention_score": 0.25,
      "sentiment_score": 0.15
    },
    "context_summary": "Se comprometió a ofrecer el producto del mes en cada venta."
  }
]
```

### Paso 4. Arma tu skill con memoria

Este skill revisa todo el historial de la persona y devuelve los momentos más importantes para que el agente retome la conversación donde se quedó:

**retomar_seguimiento**

##### Python

```python
import json
import episodes


async def execute(context=None):
    """
    Recupera lo más importante que la persona ha platicado con su coach
    para retomar la conversación donde se quedó.
    """
    if not context:
        return json.dumps({"error": "Este skill necesita el contexto de la conversación"})

    # Todo el historial de la persona, de lo más reciente a lo más antiguo
    items = episodes.get(context, limit=20, all=True)

    importantes = [
        e["context_summary"]
        for e in items
        if e.get("context_summary") and e.get("importance_score", 0) >= 0.7
    ]

    return json.dumps({
        "episodios_revisados": len(items),
        "para_retomar": importantes[:5],
    }, ensure_ascii=False)
```

##### Resultado

```json
{
  "episodios_revisados": 12,
  "para_retomar": [
    "Diego quiere mejorar su venta cruzada en calzado deportivo.",
    "Se comprometió a ofrecer el producto del mes en cada venta."
  ]
}
```

> **Filtra por importancia.** Quédate con los episodios de `importance_score` alto (por ejemplo 0.7 o más) y con pocos resultados. El agente responde mejor con tres recuerdos relevantes que con cincuenta.

> **Leer solo la conversación actual requiere un chat.** Cuando el agente usa el skill dentro de un chat, las dos opciones funcionan. Si el skill se ejecuta sin conversación (por ejemplo, una invocación directa desde otro sistema), `all=False` falla con un error: usa `all=True` o atrapa el error como en el ejemplo de abajo.

**Conversación actual, con respaldo**

```python
import json
import episodes


async def execute(context=None):
    """Resume lo importante de esta misma conversación."""
    try:
        items = episodes.get(context, limit=10, all=False)
    except ValueError:
        # Sin conversación (por ejemplo, una invocación directa): usa todo el historial
        items = episodes.get(context, limit=10, all=True)

    resumenes = [e["context_summary"] for e in items if e.get("context_summary")]
    return json.dumps({"episodios_usados": len(resumenes), "resumenes": resumenes}, ensure_ascii=False)
```

|  | `knowledge` | `episodes` |
| --- | --- | --- |
| Qué consulta | Los documentos de tu empresa | Lo que la persona ha platicado con sus agentes |
| De quién | De tu organización, según los permisos de cada documento | Solo de la persona de la conversación |
| Qué devuelve | Fragmentos del contenido de los documentos | Resumen, calificación y señales de cada episodio |
| Úsalo para | Responder con información oficial | Personalizar y dar seguimiento |

Las dos se importan igual (`import knowledge`, `import episodes`) y se pueden combinar en el mismo skill. Para administrar los documentos, consulta la guía [Base de conocimiento](https://docs.cody-tech.com/academy/ams/base-de-conocimiento).

## 8. Preguntas frecuentes: Dudas comunes

Lo que más nos preguntan sobre los skills.

### El botón «Crear» está desactivado.

Revisa que el **Nombre** solo tenga letras, números, guion bajo o guion, y que haya al menos un agente en **Agentes asignados**.

### No puedo usar la pestaña «Prueba».

Guarda el skill primero y asígnale al menos un agente.

### El agente no usa mi skill.

Revisa que el skill esté **Activo**, que el agente esté asignado y que la **Descripción** explique cuándo usarlo. Revisa las conversaciones del agente en la guía [Ajusta y supervisa tus agentes](https://docs.cody-tech.com/academy/ams/agentes).

### Mi skill con `episodes` regresa una lista vacía.

La persona todavía no tiene episodios guardados, o pediste `all=False` en una conversación que apenas empieza. Prueba con `all=True` para leer todo su historial.

### ¿Puedo editar un Plugin?

Puedes revisar su código y sus agentes, pero su tipo no cambia. Si necesitas una variante, crea una Herramienta nueva a partir de él.

## ¿Necesitas ayuda?

Si un skill no se guarda o la prueba falla sin un mensaje claro, escríbenos con una captura de la pantalla y el nombre del skill. Nunca incluyas llaves, contraseñas ni datos personales en el mensaje.
