Agents, skills & prompts

Three resource pages power the agentic side of the Space: the agent catalog (/space/agents), skills (/space/skills) and the prompt library (/space/prompts). This page documents all three and the hierarchy system that lets you compose agents.

New to the AI side? Read AI concepts from scratch first — What makes something an agent, Function/tool calling and Reasoning, which this page assumes.

The concepts behind agents

An agent is a loop that reasons with an LLM, decides, calls tools, observes results and iterates until it reaches a goal — not a one-shot chatbot. Two ingredients make the catalog agents actually work:

The system prompt. Everything an agent is lives here: its identity (<identity>), what it can do (<capabilities>), which tools it may call (<tools>), and its hard rules (<constraints>). Every request re-injects this prompt into the model’s context window, which — because the model has no memory after training — is the only way to give an agent a persistent role.
Tool/function calling. Tools are the agent’s hands. The model emits a request to call a tool (e.g. github.create_issue) with arguments; the platform runs the real API call and feeds the result back into context so the agent can reason over the outcome. This is what turns a text generator into an actor.

Orchestration composes agents: a Lead Orchestrator plans and delegates to specialists; the hierarchy spawns executors/verifiers/helpers as a tree, each with its own model. The plan itself is recovered via structured output (a schema-shaped plan + tolerant parsing). See AI concepts from scratch for the full mechanics of each.

Agent catalog

The library at /space/agents is a unified catalog of 16 built-in agents plus any custom agents you create (src/lib/agent/library.ts, AgentTemplate). Each agent has:

Name, emoji, role and a category (engineering, security, devops, data, testing, architecture, product, marketing, operations, legal).
A system prompt written in a structured XML dialect (<agent><identity>…<capabilities>…<tools>…<constraints>…</agent>).
Recommended tools (github, sandbox, code-interpreter, browser, api-request…).
A default model and pricing tier (starter / professional / enterprise).
A YAML frontmatter snippet (name, description, tools, model) used for specs.

Built-in agents

Agent	Role	Category
Software Engineer	Full-Stack Developer	engineering
Product Architect	System Designer	engineering
DevOps Engineer	Infrastructure & CI/CD	engineering
AI Software Engineer	LLM application development	engineering
Security Auditor	Threat & compliance review	security
Data Scientist	Analysis & modeling	data
Web Scraper	Extraction & parsing	data
Marketing Strategist	Campaign strategy	marketing
SEO & Content Strategist	Organic growth	marketing
Email Marketer	Outbound sequences	marketing
Content Writer	Copy & long-form	marketing
Social Media Manager	Channel publishing	marketing
Lead Orchestrator	Multi-agent delegation	operations
Growth Lead	Funnel optimization	operations
Customer Researcher	Insight synthesis	operations
Legal Reviewer	Contract & risk review	legal

The catalog view supports search, category filtering, a spec/YAML detail modal and “Add to Squad” to compose a team. Custom agents you create through the library merge into the same catalog on top of the built-ins.

Agent hierarchy

/space/hierarchy manages spawned sub-agents as a tree (src/lib/agent/hierarchy.ts, singleton-backed Postgres persistence):

The hierarchy realises multi-agent orchestration: the root orchestrator decomposes a goal, spawns executors (which may spawn their own), and verifiers check work before it merges back. Depth is capped at 3 levels and verifiers/helpers are leaves so the tree can’t sprawl infinitely.

Roles: orchestrator (root), executor, verifier, helper.
Models: GPT-4o, Claude 3.5, Groq Llama 3 (per-node selection).
Depth limit: sub-agents can be spawned up to 3 levels deep; verifiers/helpers are leaves (cannot spawn).
Status: idle → working → done / failed / waiting.

Each node tracks its own status dot, model label and children. The hierarchy is the backbone of multi-agent orchestration: the orchestrator decomposes a task, spawns executors, and verifiers check the results before merging back.

Skills

/space/skills is the reusable capability store (SkillsPanel, backed by AGENT_SKILLS_CATALOG). A skill has a name, description, trigger, instructions, category, tags, visibility and optional tools.

Prompt library

/space/prompts is the collection of reusable prompts (builtInPrompts in prompt-library-panel.tsx). Each prompt has a title, a slash trigger, content, category, tags and visibility.

Built-in triggers

Trigger	Prompt
`/review`	Code review: performance, security, style, edge cases
`/explain`	Explain a concept simply + analogy + example
`/optimize`	Performance optimization with before/after benchmarks
`/analyze`	Data/metrics analysis with trends, anomalies, takeaways
`/debug`	Root-cause stack-trace analysis with fix + diff
`/strategy`	Executive decision memo (Pyramid Principle)
`/saas-metrics`	SaaS unit-economics audit (NRR, CAC payback, LTV:CAC, Magic Number, Rule of 40)
`/cold-email`	3-touch B2B cold email sequence
`/legal-review`	Contract redlining: liability, indemnification, IP

Prompt categories: strategy, finance & FP&A, marketing & sales, legal & contracts, AI-tool prompts, development, analysis, debugging, and My Templates for your own saved prompts.

How the three combine

A typical flow: the Lead Orchestrator (from the agent catalog) plans a task → it spawns executors in the hierarchy with specific models → each executor uses its skills for repeatable procedures → and you can inject prompts from the library (e.g. /review) to standardize quality gates. All of it runs through the same /api/chat streaming pipeline with per-step usage tracking.