opción
HogarHogar Skill Otros multica-creating-agents

multica-creating-agents

multica-ai/multica multica-ai/multica

Utilizar al crear, inspeccionar o depurar un agente Multica a través de la CLI `multica agent` o de `POST /api/agents` : qué es cada campo, su formato de almacenamiento, si se trata únicamente de metadatos o si el daemon los utiliza en el momento de la reclamación, qué entradas se validan o se rechazan, cómo se controlan los secretos de `custom_env` y cómo funciona la vinculación de habilidades. No sirve para asignar incidencias a agentes existentes ni para solicitudes de tareas en tiempo de ejecución.

...Expandir todo
80
Tiempo actualizado 12 de agosto de 2026

Creación de agentes de Multica

Este es el contrato para la ruta de creación de agentes de Multica: qué aceptan los puntos de entrada de creación, qué valida y rechaza el servidor, cómo se almacena cada campo y qué campos lee realmente el demonio en el momento de la reclamación. No se trata de un manual de parámetros, sino que expone hechos rastreados hasta el código fuente, y cada afirmación está respaldada por la referencia «archivo:línea» en references/creating-agents-source-map.md.

Inicio rápido (inspección de solo lectura)

Estos comandos leen el estado y no tienen efectos secundarios:

multica agent get  --output json      # registro completo del agente almacenado
multica agent skills list  --output json   # enlaces de habilidades actuales
multica agent env get  --output json  # entorno en texto plano (solo propietario/administrador; denegado a los agentes)

La orden «agent get» devuelve el agente guardado, incluyendo runtime_id, model, thinking_level, service_tier, custom_args, has_custom_env, custom_env_key_count y skills. Nunca devuelve custom_env en texto plano.

Modelo básico

Un agente es una fila con ámbito de espacio de trabajo (tabla «agent»). Su creación se realiza mediante una única petición POST a /api/agents (multica agent create). En el momento de la reclamación de la tarea, el daemon vuelve a leer la fila del agente y ensambla la carga útil de tiempo de ejecución; por lo tanto, son los campos persistidos, y no la salida del momento de la creación, los que el agente utiliza para ejecutarse.

Dos campos de texto distintos, que a menudo se confunden:

  • «description» es un resumen del catálogo. Se almacena y se muestra en los listados; el daemon NO lo inserta en la indicación de ejecución del agente. Trátalo únicamente como metadatos destinados a los usuarios. Tiene un límite de 255 puntos de código Unicode.
  • Las «instrucciones» son el contrato de comportamiento en tiempo de ejecución. El demonio las lee en el momento de la solicitud y las envía al proveedor como las instrucciones permanentes del agente. La identidad, las responsabilidades, los límites, la salida y las reglas de escalación van aquí, no en la «descripción».

Puntos de entrada de la CLI/API

Llamada mínima de creación (se requieren tanto--name como --runtime-id ):

multica agent create --name  --runtime-id  \
  --description "" \
  --instructions "" \
  --output json

runAgentCreate genera un cuerpo JSON y lo envía a /api/agents. Solo añade una clave cuando se ha proporcionado su parámetro correspondiente—descripción/instrucciones con un valor no vacío; el resto (runtime-config, custom-args, model, thinking-level, service-tier, visibility, …) se asigna según el valor de la bandera — de modo que las banderas omitidas se sustituyen por los valores predeterminados del servidor en lugar de enviar cadenas vacías.

El cuerpo HTTP (CreateAgentRequest) acepta: name, description, instructions, avatar_url, runtime_id, runtime_config, custom_env, custom_args, model, thinking_level, service_tier, visibility, max_concurrent_tasks, mcp_config.

Contratos de campos

Valores por defecto cuando se omiten: runtime_config{}, custom_env{}, custom_args[], avatar_url → un emoji aleatorio :, visibilityprivate, max_concurrent_tasks6 (todo ello materializado en el lado del servidor antes de la inserción).custom_args/runtime_config tienen el tipo []string/any y se marshalizan tal cual; el rechazo por la estructura JSON se produce en la CLI, no en el controlador de creación.

thinking_level solo se valida a nivel del proveedor: los proveedores de catálogo fijo rechazan un literal no reconocido, mientras que los proveedores de catálogo dinámico, como Codex/OpenCode, aceptan un token sintácticamente válido. Un valor no compatible con el modelo elegido NO se rechaza aquí: el daemon comprueba su catálogo de modelos local en tiempo de ejecución, registra una advertencia y omite la sobrescritura incompatible.

Configúralo desde la CLI con --thinking-level al crear y actualizar un agente, al igual que con --model: el indicador es un simple paso al campo de nivel superior thinking_level, y al actualizarlo, una cadena vacía (--thinking-level "") lo restablece al valor predeterminado del tiempo de ejecución. La CLI no enumera deliberadamente los niveles válidos, ya que son específicos del tiempo de ejecución y del modelo (Claude utiliza actualmente low|medium|high|xhigh|max; los valores de Codex se obtienen del catálogo de modelos del tiempo de ejecución). Reenvía el token, el servidor aplica la enumeración fija o la puerta de token seguro del proveedor, y el daemon realiza la comprobación exacta del modelo y el nivel. Un entorno de ejecución cuyo proveedor no tenga el concepto «thinking» rechaza cualquier valor no vacío con un 400.

service_tier es el control de velocidad de Codex de primera clase correspondiente. Configúralo con --service-tier al crear o actualizar; utiliza --service-tier "" al actualizar para borrarlo. El catálogo de modelos del entorno de ejecución contiene tanto la copia de disponibilidad como la de visualización (actualmente «priority», que se muestra como «Fast»). El servidor acepta ID de catálogo de Codex futuros seguros, mientras que el daemon verifica el par exacto de modelo/nivel antes de la ejecución y omite cualquier anulación obsoleta e incompatible. Los agentes sin un modelo explícito fallan en estado cerrado porque se desconoce el modelo efectivo de config.toml.

modelo frente a custom_args

«model» es una columna persistente de primera clase que el demonio lee directamente. «custom_args» son argumentos sin procesar de la CLI del proveedor. La ayuda de la CLI señala que algunos proveedores (codex app-server, openclaw) rechazan «--model» dentro de «custom_args», pero se trata de una recomendación documentada de la CLI, no de una invariante impuesta por el servidor; nada en el controlador de creación inspecciona «custom_args» en busca de un indicador de modelo.

Entorno y secretos

`custom_env` contiene información confidencial. La CLI ofrece tres canales de entrada; dos mantienen los secretos fuera del historial del shell y de la lista de procesos:

multica agent create --name  --runtime-id  --custom-env-stdin --output json
multica agent create --name  --runtime-id  --custom-env-file <0600-json> --output json

--custom-env-stdin lee el objeto JSON desde la entrada estándar; --custom-env-file lo lee desde un archivo (se recomienda el modo 0600). El tercer canal, --custom-env , coloca el valor en la línea de comandos, donde el historial del shell y el comando ps pueden verlo; evítalo para secretos reales.

Datos sobre la lectura (estas son las suposiciones erróneas que hay que evitar):

  • Los recursos del agente nunca exponen custom_env en texto plano. Las operaciones list/get/create/update del agente y los eventos de WS solo devuelven has_custom_env (bool) y custom_env_key_count (int).
  • Para leer valores en texto plano es necesario utilizar el punto final GET /api/agents/{id}/env (multica agent env get). Su acceso está restringido a los propietarios y administradores del espacio de trabajo, y se deniega a los agentes independientemente del rol del miembro que los respalde: un agente en ejecución no puede leer los secretos de otro agente.
  • La escritura de valores tras la creación NO se realiza a través de la actualización del agente. El gestor genérico de actualizaciones rechaza cualquier campo «custom_env» con un código 400 («utiliza PUT /api/agents/{id}/env»). Las escrituras de entorno en texto plano se gestionan mediante PUT /api/agents/{id}/env (configuración del entorno del agente de Multica), que es de uso exclusivo del propietario o administrador y genera una entrada de auditoría.

mcp_config

mcp_config es la configuración del servidor MCP del agente (un objeto JSON como {"mcpServers": {…}}). También se trata de información confidencial —las entradas MCP suelen incluir tokens de API— y ofrece los mismos tres canales de entrada que custom_env, tanto enla creación como en la actualización del agente:

multica agent create --name  --runtime-id  --mcp-config-file <0600-json> --output json
multica agent update  --mcp-config-stdin --output json
multica agent update  --mcp-config 'null'   # borra la configuración

--mcp-config-stdin / --mcp-config-file mantienen el valor fuera del historial del shell y de ps; la opción en línea --mcp-config no lo hace. La CLI requiere unobjeto JSON o el valor literal null; un array de nivel superior o un tipo primitivo se rechaza en el lado del cliente, y una entrada vacía de stdin o de un archivo genera un error en lugar de borrarse silenciosamente.

Hay dos diferencias entre mcp_config y custom_env:

  • SÍ se puede configurar mediante la actualización del agente. A diferencia de custom_env, mcp_config no tiene un punto final auditado específico: el PUT genérico /api/agents/{id} lo acepta. Tres estados según el cuerpo de la solicitud sin procesar: campo omitido → sin cambios; null → borrar; objeto → sustituir.
  • Se serializa al leerlo, pero se censura.Las llamadas get/list del agente devuelven mcp_config solo a los usuarios autorizados a ver los secretos del agente; en caso contrario, el campo es nulo y mcp_config_redacted es verdadero. Los actores del agente nunca lo ven, y un espacio de trabajo puede forzar la censura para todos.

La compatibilidad de los proveedores no es uniforme: Qwen Code acepta un mcp_config gestionado a través de un archivo JSON temporal 0600 propiedad del daemon, pasado con --mcp-config; se elimina al finalizar la ejecución. Deja el campo sin definir (nulo) para heredar la configuración nativa de Qwen Code.

Asignación de habilidades

La creación de un agente NO vincula ninguna habilidad del espacio de trabajo; la vinculación es una llamada independiente que se realiza una vez creado el agente. Hay dos verbos distintos:

  • add es aditivo: fusiona los ID proporcionados con las vinculaciones existentes (POST /api/agents/{id}/skills/add).
  • set sustituye todo: sobrescribe toda la lista de vinculaciones exactamente por los identificadores proporcionados (PUT /api/agents/{id}/skills); --skill-ids '' borra todo.
multica agent skills add  --skill-ids  --output json
multica agent skills list  --output json

En el momento de la solicitud, el demonio agrupa PRIMERO las habilidades del agente como habilidades vinculadas al espacio de trabajo y, a continuación, añade las habilidades integradas en la plataforma. LoadAgentSkills carga el contenido de cada habilidad vinculada junto con sus archivos de apoyo; las habilidades integradas se incorporan en tiempo de compilación y se cargan desde SKILL.md y los archivos relacionados. Ambas llegan al proveedor como contenido de la habilidad, razón por la cual la capacidad debe figurar en una habilidad vinculada, y no pegarse en las instrucciones.

Efectos secundarios que requieren aprobación

Solo lectura (seguro): obtener agente, lista de habilidades del agente, obtener entorno del agente.

Que modifican el estado (requieren una instrucción explícita; no se deben ejecutar de forma especulativa):

  • creación de agente multica: inserta una nueva fila de agente.
  • multica agent skills add / set: modifica los enlaces (set es destructivo: elimina los enlaces que no están en la nueva lista).
  • multica agent env set — sobrescribe todo el mapa custom_env y escribe una fila de auditoría.

Supuestos erróneos habituales

  • «La descripción es la línea de comandos». No es así: solo las instrucciones llegan al entorno de ejecución. Una descripción detallada con instrucciones vacías da lugar a un shell con nombre pero sin contrato operativo.
  • «Create vincula las habilidades del agente». No es así; hay que vincularlas explícitamente después.
  • «La actualización del agente puede rotar el entorno». No es así: devuelve un error 400 en ` custom_env`; utiliza el punto final del entorno.
  • «mcp_config se comporta como custom_env al actualizar». No es así: mcp_config SE PUEDE configurar mediante agent update (--mcp-config), con --mcp-config nulo para borrarlo; solo custom_env está restringido tras el punto final dedicado a env.
  • «La consultaget del agente muestra los valores de env». Solo muestra has_custom_env y custom_env_key_count.
  • «Se detecta una combinación inválidade thinking_level/model al crearlo». Solo se detecta un literal desconocido a nivel de proveedor; las discrepancias específicas del modelo fallan en tiempo de ejecución.
  • «set y add son intercambiables para las habilidades». set sustituye todos los enlaces; si se utiliza cuando se pretendía usar add, se eliminan silenciosamente las capacidades.

Referencias

references/creating-agents-source-map.md asigna cada contrato anterior a su archivo:línea en el árbol actual, el efecto en tiempo de ejecución y un comando de verificación seguro de solo lectura .

Ver en GitHub

Creating Multica agents

This is the contract for Multica's agent-creation path: what the create entry points accept, what the server validates and rejects, how each field is persisted, and which fields the daemon actually reads at claim time. It is not a parameter manual — it states source-traced facts, and every claim is backed by file:line in references/creating-agents-source-map.md.

Quick start (read-only inspection)

These commands read state and have no side effects:

multica agent get <agent-id> --output json      # full persisted agent record
multica agent skills list <agent-id> --output json   # current skill bindings
multica agent env get <agent-id> --output json  # plaintext env (owner/admin only, agents denied)

agent get returns the persisted agent including runtime_id, model, thinking_level, service_tier, custom_args, has_custom_env, custom_env_key_count, and skills. It never returns plaintext custom_env.

Core model

An agent is a workspace-scoped row (table agent). Creation is a single POST /api/agents (multica agent create). At task claim time the daemon re-reads the agent row and assembles the runtime payload — so the persisted fields, not the create-time output, are what the agent runs on.

Two distinct text fields, often confused:

  • description is a catalog summary. It is stored and shown in listings; the daemon does NOT inject it into the agent's runtime prompt. Treat it as human-facing metadata only. Capped at 255 Unicode code points.
  • instructions is the runtime behavior contract. The daemon reads it at claim time and ships it to the provider as the agent's durable instructions. Persona, responsibilities, boundaries, output and escalation rules go here, not in description.

CLI / API entry points

Minimum create call (--name and --runtime-id are both required):

multica agent create --name <name> --runtime-id <runtime-id> \
  --description "<short catalog summary>" \
  --instructions "<runtime behavior contract>" \
  --output json

runAgentCreate builds a JSON body and posts it to /api/agents. It only adds a key when its flag was provided — description/instructions on a non-empty value, the rest (runtime-config, custom-args, model, thinking-level, service-tier, visibility, …) on the flag being Changed — so omitted flags fall through to server defaults rather than sending empty strings.

The HTTP body (CreateAgentRequest) accepts: name, description, instructions, avatar_url, runtime_id, runtime_config, custom_env, custom_args, model, thinking_level, service_tier, visibility, max_concurrent_tasks, mcp_config.

Field contracts

Defaults when omitted: runtime_config{}, custom_env{}, custom_args[], avatar_url → a random emoji:<glyph>, visibilityprivate, max_concurrent_tasks6 (all materialized server-side before the insert). custom_args/runtime_config are typed []string/any and marshaled as-is — the JSON-shape rejection happens in the CLI, not the create handler.

thinking_level is validated only at the provider level: fixed-catalog providers reject an unrecognized literal, while dynamic-catalog providers such as Codex/OpenCode accept a syntactically safe token. A value unsupported for the chosen model is NOT rejected here — the daemon checks its local model catalog at execution time, logs a warning, and omits the incompatible override.

Set it from the CLI with --thinking-level on agent create and agent update, mirroring --model: the flag is a thin pass-through to the top-level thinking_level field, and on update an empty string (--thinking-level "") clears it back to the runtime default. The CLI deliberately does not enumerate the valid levels — they are runtime/model-specific (Claude currently uses low|medium|high|xhigh|max; Codex values are discovered from the runtime's model catalog). It forwards the token, the server applies the provider's fixed-enum or safe-token gate, and the daemon performs the exact model/level check. A runtime whose provider has no thinking concept rejects any non-empty value with a 400.

service_tier is the matching first-class Codex speed control. Set it with --service-tier <catalog-id> on create/update; use --service-tier "" on update to clear it. The runtime model catalog owns both availability and display copy (currently priority, shown as Fast). The server accepts safe future Codex catalog IDs, while the daemon verifies the exact model/tier pair before execution and omits a stale incompatible override. Agents without an explicit model fail closed because the effective config.toml model is unknown.

model vs custom_args

model is a first-class persisted column the daemon reads directly. custom_args are raw provider CLI args. The CLI help notes that some providers (codex app-server, openclaw) reject --model inside custom_args — but that is documented CLI guidance, not a server-enforced invariant; nothing in the create handler inspects custom_args for a model flag.

Env & secrets

custom_env is secret material. The CLI offers three input channels; two keep secrets out of shell history and the process list:

multica agent create --name <name> --runtime-id <runtime-id> --custom-env-stdin --output json
multica agent create --name <name> --runtime-id <runtime-id> --custom-env-file <0600-json> --output json

--custom-env-stdin reads the JSON object from stdin; --custom-env-file reads it from a file (suggested mode 0600). The third channel, --custom-env <json>, puts the value on the command line where shell history and ps can see it — avoid it for real secrets.

Read-side facts (these are the wrong assumptions to avoid):

  • Agent resources never expose plaintext custom_env. agent list/get/create/update and WS events return only has_custom_env (bool) and custom_env_key_count (int).
  • Reading plaintext values requires the dedicated GET /api/agents/{id}/env endpoint (multica agent env get). It is gated to workspace owner/admin members, and agent actors are denied regardless of the backing member's role — a running agent cannot read another agent's secrets.
  • Writing values after creation does NOT go through agent update. The generic update handler rejects any custom_env field with a 400 ("use PUT /api/agents/{id}/env"). Plaintext env writes are handled by PUT /api/agents/{id}/env (multica agent env set), which is owner/admin-only and writes an audit row.

mcp_config

mcp_config is the agent's MCP server configuration (a JSON object such as {"mcpServers": {…}}). It is also secret material — MCP entries routinely embed API tokens — and offers the same three input channels as custom_env, on BOTH agent create and agent update:

multica agent create --name <name> --runtime-id <runtime-id> --mcp-config-file <0600-json> --output json
multica agent update <agent-id> --mcp-config-stdin --output json
multica agent update <agent-id> --mcp-config 'null'   # clears the config

--mcp-config-stdin / --mcp-config-file keep the value out of shell history and ps; the inline --mcp-config <json> does not. The CLI requires a JSON object or the literal null; a top-level array or primitive is rejected client-side, and empty stdin/file input errors rather than silently clearing.

Two ways mcp_config differs from custom_env:

  • It IS settable through agent update. Unlike custom_env, mcp_config has no dedicated audited endpoint — the generic PUT /api/agents/{id} accepts it. Tri-state per the raw request body: field omitted → no change; null → clear; object → replace.
  • It is serialized on read, but redacted. agent get/list return mcp_config only to callers allowed to view agent secrets; otherwise the field is null and mcp_config_redacted is true. Agent actors never see it, and a workspace may force redaction for everyone.

Provider support is not uniform: Qwen Code accepts a managed mcp_config through a daemon-owned 0600 temporary JSON file passed with --mcp-config; it is removed when the run exits. Leave the field unset (null) to inherit Qwen Code native settings.

Skill binding

Creating an agent does NOT bind any workspace skill — binding is a separate call after the agent exists. Two distinct verbs:

  • add is additive — it merges the given ids with existing bindings (POST /api/agents/{id}/skills/add).
  • set is replace-all — it overwrites the entire binding list with exactly the given ids (PUT /api/agents/{id}/skills); --skill-ids '' clears all.
multica agent skills add <agent-id> --skill-ids <skill-id> --output json
multica agent skills list <agent-id> --output json

At claim time the daemon assembles the agent's skills as workspace-bound skills FIRST, then appends the platform built-in skills. LoadAgentSkills loads each bound skill's content plus its supporting files; built-in skills are embedded at compile time and loaded from SKILL.md + sibling files. Both reach the provider as skill content — which is why capability belongs in a bound skill, not pasted into instructions.

Side effects needing approval

Read-only (safe): agent get, agent skills list, agent env get.

State-changing (require an explicit instruction — do not run speculatively):

  • multica agent create — inserts a new agent row.
  • multica agent skills add / set — mutate bindings (set is destructive: it drops bindings not in the new list).
  • multica agent env set — overwrites the full custom_env map and writes an audit row.

Common wrong assumptions

  • "description is the prompt." It is not — only instructions reaches the runtime. A rich description with empty instructions yields a named shell with no operating contract.
  • "Create binds the agent's skills." It does not; bind explicitly afterward.
  • "agent update can rotate env." It cannot — it 400s on custom_env; use the env endpoint.
  • "mcp_config behaves like custom_env on update." It does not — mcp_config IS settable via agent update (--mcp-config), with --mcp-config null to clear; only custom_env is gated behind the dedicated env endpoint.
  • "agent get shows env values." It shows only has_custom_env and custom_env_key_count.
  • "An invalid thinking_level/model combo is caught at create." Only an unknown provider-level literal is — model-specific gaps fail at run time.
  • "set and add are interchangeable for skills." set replaces all bindings; using it when you meant add silently removes capabilities.

References

references/creating-agents-source-map.md maps every contract above to its file:line on the current tree, the runtime effect, and a safe read-only verification command.

Todos los archivos

0 archivos

Instalar multica-creating-agents

Descarga y descomprime los archivos de las habilidades en tu directorio .claude/skills/.

Descargar ZIP

Clona el repositorio y copia los archivos de la habilidad a tu proyecto.

git clone https://github.com/multica-ai/multica/tree/main/server/internal/service/builtin_skills/multica-creating-agents # Copy the skill folder to .claude/skills/ or .codex/skills/

Copiar Copiar
Configuración rápida: Copia la carpeta de la habilidad en .claude/skills/. Claude la detectará automáticamente y utilizará la habilidad.
Repositorio multica-ai/multica

Habilidades relacionadas

tilemaps
Tiempo actualizado 4 de agosto de 2026
v4-new-features
Tiempo actualizado 4 de agosto de 2026
agent-github-pr-manager
Tiempo actualizado 3 de agosto de 2026
pixijs-application
Tiempo actualizado 4 de agosto de 2026
OR