Option
HeimHeim Skill Sonstiges multica-creating-agents

multica-creating-agents

multica-ai/multica 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 erweitern
80
Zeit aktualisiert 12. August 2026

Erstellen 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 in die „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:, visibilityprivate, max_concurrent_tasks6 (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“-Feld mit einem 400-Fehler ab („use PUT /api/agents/{id}/env“). Das Schreiben von Umgebungsvariablen im Klartext wird über PUT /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-Update einstellbar. Im Gegensatz zu custom_env verfügt mcp_config über keinen dedizierten, auditierten Endpunkt – der generische PUT-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/list geben mcp_config nur an Aufrufer zurück, die zur Einsicht in Agent-Geheimnisse berechtigt sind; andernfalls ist das Feld null und mcp_config_redacted ist wahr. 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 (set ist destruktiv: es löscht Bindungen, die nicht in der neuen Liste enthalten sind).
  • multica agent env set – überschreibt die gesamte „custom_env“-Map und schreibt eine Audit-Zeile.

Häufige falsche Annahmen

  • Die Beschreibung ist die Eingabeaufforderung.“ Das ist nicht der Fall – nur Anweisungen gelangen 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_config verhält sich bei einem Update wie custom_env.“ Das tut es nicht – mcp_config kann über `agent update ` (--mcp-config) gesetzt werden, wobei --mcp-config null gesetzt wird, um es zu löschen; nur custom_env wird ü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 Kombinationaus thinking_level und model wird beim Erstellen erkannt.“ Dies gilt nur für unbekannte Literale auf Anbieterebene – modellspezifische Lücken führen zu Fehlern zur Laufzeit.
  • set und add sind bei Skills austauschbar.“ set ersetzt alle Bindungen; wenn Sie es verwenden, obwohl Sie add gemeint 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.

Auf GitHub ansehen

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.

Alle Dateien

0 Dateien

multica-creating-agents installieren

Laden Sie die Skill-Dateien herunter und entpacken Sie sie in Ihr Verzeichnis „.claude/skills/“.

ZIP herunterladen

Klonen 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 Kopieren
Schnelle Einrichtung: Kopiere den Skill-Ordner nach „.claude/skills/“. Claude erkennt den Skill automatisch und nutzt ihn.
Repository multica-ai/multica

Ähnliche Skills

tilemaps
Zeit aktualisiert 4. August 2026
v4-new-features
Zeit aktualisiert 4. August 2026
agent-github-pr-manager
Zeit aktualisiert 3. August 2026
pixijs-application
Zeit aktualisiert 4. August 2026
OR