multica-creating-agents
multica-ai/multica
Verwendung beim Erstellen, Überprüfen oder Debuggen eines Multica-Agenten über die CLI `multica agent` oder `POST /api/agents` — was die einzelnen Felder bedeuten, in welcher Form sie gespeichert werden, ob es sich um reine Metadaten handelt oder ob sie vom Daemon zum Zeitpunkt der Inanspruchnahme verarbeitet werden, welche Eingaben validiert bzw. abgelehnt werden, wie „custom_env“-Geheimnisse geschützt werden und wie sich die Skill-Bindung verhält. Nicht zur Zuweisung von Issues an bestehende Agenten oder für Aufgabenaufforderungen zur Laufzeit.
...Alle erweiternErstellen von Multica-Agenten
Dies ist die Spezifikation für den Erstellungsweg von Multica-Agenten: Was die Erstellungs-Einstiegspunkte
akzeptieren, was der Server validiert und ablehnt, wie jedes Feld
persistiert wird und welche Felder der Daemon zum Zeitpunkt der Anforderung tatsächlich ausliest. Es handelt sich
nicht um ein Parameterhandbuch – es enthält auf den Quellcode zurückverfolgbare Fakten, und jeder Anspruch wird
durch „Datei:Zeile“ in „references/creating-agents-source-map.md“ belegt.
Schnellstart (schreibgeschützte Überprüfung)
Diese Befehle lesen den Status aus und haben keine Nebenwirkungen:
multica agent get --output json # vollständiger persistierter Agent-Datensatz
multica agent skills list --output json # aktuelle Skill-Zuordnungen
multica agent env get --output json # Umgebungsvariablen im Klartext (nur für Eigentümer/Administratoren, Agenten haben keinen Zugriff)
„agent get“ gibt den gespeicherten Agenten zurück, einschließlich runtime_id, model,
thinking_level, service_tier, custom_args, has_custom_env,
custom_env_key_count und skills. Es gibt niemals „custom_env“ im Klartext zurück.
Kernmodell
Ein Agent ist eine Zeile im Arbeitsbereich (Tabelle „agent“). Die Erstellung erfolgt über einen einzelnen
POST-Aufruf an /api/agents (multica agent create). Zum Zeitpunkt der Aufgabenübernahme liest der Daemon
die Agent-Zeile erneut ein und stellt die Laufzeit-Nutzlast zusammen – daher basieren die Ausführungen des Agenten auf den persistierten
Feldern und nicht auf den Werten zum Zeitpunkt der Erstellung.
Zwei unterschiedliche Textfelder, die oft verwechselt werden:
„description“ist eine Katalogzusammenfassung. Sie wird gespeichert und in Listen angezeigt; der Daemon fügt sie NICHT in die Laufzeit-Eingabeaufforderung des Agenten ein. Behandeln Sie sie ausschließlich als für Menschen bestimmte Metadaten. Begrenzt auf 255 Unicode-Codepunkte.„instructions“ist die Vereinbarung zum Laufzeitverhalten. Der Daemon liest sie zum Zeitpunkt der Anforderung und übermittelt sie als dauerhafte Anweisungen des Agenten an den Anbieter. Persona, Verantwortlichkeiten, Grenzen, Ausgabe- und Eskalationsregeln gehören hierher, nicht indie „description“.
CLI-/API-Einstiegspunkte
Mindestanforderung für den Erstellungsaufruf (--name und --runtime-id sind beide erforderlich):
multica agent create --name --runtime-id \
--description "" \
--instructions "" \
--output json
runAgentCreate erstellt einen JSON-Body und sendet ihn an /api/agents. Es fügt nur
dann einen Schlüssel hinzu, wenn das entsprechende Flag angegeben wurde –description/instructions mit einem
nicht leeren Wert, den Rest (runtime-config, custom-args, model,
thinking-level, service-tier, visibility, …) bei Änderung des Flags – so werden
weggelassene Flags auf die Server-Standardwerte zurückgesetzt, anstatt leere Zeichenfolgen zu senden.
Der HTTP-Body (CreateAgentRequest) akzeptiert: name, description,
instructions, avatar_url, runtime_id, runtime_config, custom_env,
custom_args, model, thinking_level, service_tier, visibility,
max_concurrent_tasks, mcp_config.
Feldkonventionen
Standardwerte bei Weglassung: runtime_config → {}, custom_env → {},
custom_args → [], avatar_url → ein zufälliges Emoji:, visibility →
private, max_concurrent_tasks → 6
(alles wird vor dem Einfügen serverseitig materialisiert).custom_args/runtime_config
sind vom Typ []string/any und werden unverändert marshaled – die Ablehnung aufgrund der JSON-Struktur
erfolgt in der CLI, nicht im Create-Handler.
„thinking_level“ wird nur auf Anbieterebene validiert: Anbieter mit festem Katalog
lehnen ein unbekanntes Literal ab, während Anbieter mit dynamischem Katalog wie
Codex/OpenCode ein syntaktisch korrektes Token akzeptieren. Ein Wert, der für
das gewählte Modell nicht unterstützt wird, wird hier NICHT abgelehnt – der Daemon überprüft seinen lokalen Modellkatalog
zur Laufzeit, protokolliert eine Warnung und lässt die inkompatible Überschreibung außer Acht.
Stellen Sie ihn über die CLI mit `--thinking-level` bei `agent create ` und `agent update` ein, analog zu `--model`: Das Flag ist eine einfache Weiterleitung an das oberste
`thinking_level` -Feld, und bei einer Aktualisierung setzt eine leere Zeichenkette (`--thinking-level ""`)
den Wert wieder auf den Laufzeitschutzwert zurück. Die Befehlszeile listet bewusst nicht
die gültigen Stufen auf – sie sind laufzeit- und modellspezifisch (Claude verwendet derzeit
low|medium|high|xhigh|max; Codex-Werte werden aus dem Modellkatalog der Laufzeitumgebung
abgerufen). Sie leitet das Token weiter, der Server wendet die
„fixed-enum“- oder „safe-token“-Prüfung des Anbieters an, und der Daemon führt die genaue Modell-/Stufen-
Prüfung durch. Eine Laufzeitumgebung, deren Anbieter kein „thinking“-Konzept hat, lehnt jeden nicht leeren
Wert mit einem 400-Fehler ab.
„service_tier“ ist die entsprechende erstklassige Codex-Geschwindigkeitssteuerung. Setzen Sie sie mit
„--service-tier beim Erstellen/Aktualisieren; verwenden Sie „--service-tier ""“ beim
Aktualisieren, um sie zu löschen. Der Modellkatalog der Laufzeitumgebung verwaltet sowohl die Verfügbarkeit als auch
die Anzeigekopie (derzeit „priority“, angezeigt als „Fast“). Der Server akzeptiert sichere
zukünftige Codex-Katalog-IDs, während der Daemon das genaue Modell-/Tier-Paar
vor der Ausführung überprüft und eine veraltete, inkompatible Überschreibung auslässt. Agenten ohne ein
explizites Modell schlagen mit „closed“ fehl, da das effektive „config.toml“-Modell unbekannt ist.
Modell vs. custom_args
„model“ ist eine persistierte Spalte erster Klasse, die der Daemon direkt ausliest.
„custom_args“ sind rohe CLI-Argumente des Anbieters. In der CLI-Hilfe wird darauf hingewiesen, dass einige Anbieter
(Codex App-Server, Openclaw) „--model“ innerhalb von „custom_args“ ablehnen – dies ist jedoch
eine dokumentierte CLI-Richtlinie und keine vom Server erzwungene Invariante; im „create“-Handler
wird „custom_args“ nicht auf ein Modell-Flag überprüft.
Umgebung & Geheimnisse
„custom_env“ enthält vertrauliche Daten. Die CLI bietet drei Eingabekanäle; zwei halten
Geheimnisse aus dem Shell-Verlauf und der Prozessliste fern:
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 liest das JSON-Objekt aus der Standard-Eingabe; --custom-env-file
liest es aus einer Datei (empfohlene Berechtigung 0600). Der dritte Kanal,
--custom-env , stellt den Wert in die Befehlszeile, wo er vom Shell-Verlauf
und von `ps` eingesehen werden kann – vermeiden Sie dies bei echten Geheimnissen.
Fakten auf der Leseseite (dies sind die falschen Annahmen, die es zu vermeiden gilt):
- Agent-Ressourcen geben
„custom_env“niemals im Klartext preis. Die Befehle„agent list/get/create/update“sowie WS-Ereignisse geben nur„has_custom_env“(bool) und„custom_env_key_count“(int) zurück. - Das Auslesen von Werten im Klartext erfordert den speziellen
GET-Endpunkt /api/agents/{id}/env(multica agent env get). Der Zugriff ist auf den Workspace -Besitzer und die Administratoren beschränkt, und Agenten-Akteuren wird der Zugriff unabhängig von der Rolle des zugrunde liegenden Mitglieds verweigert – ein laufender Agent kann die Geheimnisse eines anderen Agenten nicht lesen. - Das Schreiben von Werten nach der Erstellung erfolgt NICHT über
die Agent-Aktualisierung. Der generische Update-Handler lehnt jedes„custom_env“-Feldmit einem 400-Fehler ab („use PUT /api/agents/{id}/env“). Das Schreiben von Umgebungsvariablen im Klartext wird überPUT /api/agents/{id}/env(Multica-Agent-Umgebungsvariable setzen) abgewickelt, was nur für Eigentümer/Administratoren zugänglich ist und eine Audit-Zeile schreibt.
mcp_config
mcp_config ist die MCP-Serverkonfiguration des Agenten (ein JSON-Objekt wie z. B.
{"mcpServers": {…}}). Es handelt sich ebenfalls um vertrauliche Daten – MCP-Einträge enthalten regelmäßig
API-Token – und bietet dieselben drei Eingabekanäle wie „custom_env“, sowohl beider
Agentenerstellung als auch bei der Agentenaktualisierung:
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' # löscht die Konfiguration
--mcp-config-stdin / --mcp-config-file: Der Wert wird nicht in den Shell-Verlauf
und in „ps“ übernommen; bei der Inline-Option --mcp-config ist dies nicht der Fall. Die CLI erfordert einJSON-Objekt
oder den Literalwert „null“; ein Array oder ein primitiver Typ auf oberster Ebene wird
auf Client-Seite abgelehnt, und leere Eingaben über stdin oder aus einer Datei führen zu Fehlern, anstatt stillschweigend gelöscht zu werden.
Zwei Unterschiede zwischen mcp_config und custom_env:
- Es IST über
ein Agent-Updateeinstellbar. Im Gegensatz zucustom_envverfügtmcp_configüber keinen dedizierten, auditierten Endpunkt – der generischePUT-Endpunkt /api/agents/{id}akzeptiert es. Drei Zustände je nach Rohdaten des Request-Bodys: Feld weggelassen → keine Änderung;null→ löschen; Objekt → ersetzen. - Es wird beim Lesen serialisiert, jedoch redigiert.
agentget/listgebenmcp_confignur an Aufrufer zurück, die zur Einsicht in Agent-Geheimnisse berechtigt sind; andernfalls ist das Feldnullundmcp_config_redactedistwahr. Agent-Akteure sehen es niemals, und ein Workspace kann die Redigierung für alle erzwingen.
Die Unterstützung durch Anbieter ist nicht einheitlich: Qwen Code akzeptiert ein verwaltetes `mcp_config` über eine dem Daemon gehörende temporäre JSON-Datei mit der Berechtigungsstufe 0600, die mit `--mcp-config` übergeben wird; diese wird beim Beenden des Laufs entfernt. Lassen Sie das Feld ungesetzt (null), um die nativen Einstellungen von Qwen Code zu übernehmen.
Skill-Bindung
Das Erstellen eines Agenten bindet KEINE Workspace-Skills – die Bindung erfolgt über einen separaten Aufruf, nachdem der Agent existiert. Zwei unterschiedliche Verben:
„add“ist additiv – es fügt die angegebenen IDs zu den bestehenden Bindungen hinzu (POST /api/agents/{id}/skills/add).„set“ersetzt alles – es überschreibt die gesamte Bindungsliste vollständig durch genau die angegebenen IDs (PUT /api/agents/{id}/skills);„--skill-ids “löscht alle.
multica agent skills add --skill-ids --output json
multica agent skills list --output json
Zum Zeitpunkt der Anforderung stellt der Daemon ZUERST die Fähigkeiten des Agenten als arbeitsbereichsgebundene Fähigkeiten zusammen,
dann werden die in die Plattform integrierten Fähigkeiten angehängt. „LoadAgentSkills“ lädt den Inhalt jedes
gebundenen Skills sowie dessen zugehörige Dateien; integrierte Skills werden
zur Kompilierungszeit eingebettet und aus „SKILL.md“ sowie den zugehörigen Dateien geladen. Beides gelangt als
Skill-Inhalt zum Anbieter – weshalb die Fähigkeit in einem gebundenen Skill enthalten sein sollte
und nicht in Anweisungen eingefügt werden darf.
Genehmigungspflichtige Nebenwirkungen
Schreibgeschützt (sicher): Agent abrufen, Agenten-Fähigkeitenliste, Agentenumgebung abrufen.
Zustandsändernd (erfordern eine explizite Anweisung – nicht spekulativ ausführen):
multica agent create– fügt eine neue Agentenzeile ein.multica agent skills add/set– verändert Bindungen (setist destruktiv: es löscht Bindungen, die nicht in der neuen Liste enthalten sind).multica agent env set– überschreibt die gesamte„custom_env“-Mapund schreibt eine Audit-Zeile.
Häufige falsche Annahmen
- „
Die Beschreibungist die Eingabeaufforderung.“ Das ist nicht der Fall – nurAnweisungengelangen in die Laufzeit. Eine ausführliche Beschreibung mit leeren Anweisungen führt zu einer benannten Shell ohne Ausführungskontrakt. - „Create bindet die Fähigkeiten des Agenten.“ Das tut es nicht; binde sie anschließend explizit.
- „`
agent update` kann die Umgebung rotieren.“ Das kann es nicht – es gibt einen 400-Fehler bei `custom_env`; verwende den `env`-Endpunkt. „mcp_configverhält sich bei einem Update wiecustom_env.“ Das tut es nicht –mcp_configkann über`agent update` (--mcp-config) gesetzt werden, wobei--mcp-config null gesetzt wird, um es zu löschen; nurcustom_envwird über den dedizierten env-Endpunkt gesteuert.- „`
agent get` zeigt `env`-Werte an.“ Es werden nur `has_custom_env` und `custom_env_key_count` angezeigt. - „Eine ungültige Kombination
aus thinking_level und modelwird beim Erstellen erkannt.“ Dies gilt nur für unbekannte Literale auf Anbieterebene – modellspezifische Lücken führen zu Fehlern zur Laufzeit. - „
setundaddsind bei Skills austauschbar.“setersetzt alle Bindungen; wenn Sie es verwenden, obwohl Sieaddgemeint haben, werden Fähigkeiten stillschweigend entfernt.
Referenzen
references/creating-agents-source-map.md ordnet jeden der oben genannten Verträge seiner
Datei:Zeile im aktuellen Baum, der Auswirkung zur Laufzeit und einem sicheren, schreibgeschützten
Überprüfungsbefehl zu.
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:
descriptionis 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.instructionsis 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 indescription.
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>, visibility →
private, max_concurrent_tasks → 6
(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/updateand WS events return onlyhas_custom_env(bool) andcustom_env_key_count(int). - Reading plaintext values requires the dedicated
GET /api/agents/{id}/envendpoint (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 anycustom_envfield with a 400 ("use PUT /api/agents/{id}/env"). Plaintext env writes are handled byPUT /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. Unlikecustom_env,mcp_confighas no dedicated audited endpoint — the genericPUT /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/listreturnmcp_configonly to callers allowed to view agent secrets; otherwise the field isnullandmcp_config_redactedistrue. 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:
addis additive — it merges the given ids with existing bindings (POST /api/agents/{id}/skills/add).setis 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 (setis destructive: it drops bindings not in the new list).multica agent env set— overwrites the fullcustom_envmap and writes an audit row.
Common wrong assumptions
- "
descriptionis the prompt." It is not — onlyinstructionsreaches 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 updatecan rotate env." It cannot — it 400s oncustom_env; use the env endpoint. - "
mcp_configbehaves likecustom_envon update." It does not —mcp_configIS settable viaagent update(--mcp-config), with--mcp-config nullto clear; onlycustom_envis gated behind the dedicated env endpoint. - "
agent getshows env values." It shows onlyhas_custom_envandcustom_env_key_count. - "An invalid
thinking_level/modelcombo is caught at create." Only an unknown provider-level literal is — model-specific gaps fail at run time. - "
setandaddare interchangeable for skills."setreplaces all bindings; using it when you meantaddsilently 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.
Alle Dateien
0 Dateienmultica-creating-agents installieren
Laden Sie die Skill-Dateien herunter und entpacken Sie sie in Ihr Verzeichnis „.claude/skills/“.
ZIP herunterladenKlonen Sie das Repository und kopieren Sie die Skill-Dateien in Ihr Projekt.
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/
Kopieren





Heim
