Agent Skills, Flows & Templates: Building Blocks of a Governed AI Workforce

The Capability Layer

Nexus Cascades handle scheduling, sequencing, and integration. Agent personas handle identity and governance. But the actual capabilities — the specific things an agent can do — live in the Skills system.

A skill is a discrete, reusable capability unit. An agent equipped with a skill can invoke it during cascade execution. Skills can be primitive (a single tool call) or composite (a multi-step process with internal logic). They are the building blocks from which agent capability is assembled.

What Is a Skill?

At its simplest, a skill is a named, parameterised action available to an agent:

skill: web_research
description: "Searches the web for information on a given topic"
parameters:
  - query: string
  - depth: enum [shallow, standard, deep]
  - max_sources: integer
outputs:
  - sources: array
  - summary: string
  - confidence: float

When an agent encounters a task that benefits from web research, it can invoke web_research(query="...", depth="standard") as a tool call. The skill handles the execution — hitting the search API, crawling sources, extracting content — and returns structured output the agent can reason about.

Skills abstract the implementation from the agent. The Librarian does not need to know how Spectre crawls websites — it just calls the research skill with a query.

Built-In Skills

The platform ships with a set of built-in skills available to all agents:

Research & Intelligence

web_research — General web search and content extraction
spectre_extract — Deep extraction from a specific URL
news_search — Current news retrieval on a topic
academic_search — Academic paper and citation lookup

Data & Documents

db_read / db_write — PocketBase collection access
file_read / file_write — Filesystem access within the sandbox
pdf_extract — Text extraction from PDF files
structured_output — Force agent output into a defined JSON schema

Communication

send_email — SMTP email via Sovereign Mail
discord_notify — Discord webhook notification
slack_notify — Slack webhook notification

Code & Analysis

code_exec — Execute code in a sandboxed runtime (Python, Node.js)
data_transform — CSV/JSON transformation and analysis
regex_match — Pattern matching against text

Security & Ops

geo_lookup — IP geolocation
domain_lookup — WHOIS and DNS lookup
hash_value — Cryptographic hashing for deduplication and verification

Custom Skills

Pro and Enterprise plans support custom skill definitions. A custom skill is a YAML definition that wraps an HTTP endpoint, a code execution block, or a sequence of built-in skills:

skill: competitor_pricing_check
description: "Extracts current pricing from a competitor domain"
type: composite
steps:
  - skill: spectre_extract
    params:
      url: "$params.domain$/pricing"
      selector: "[data-pricing], .pricing-table, h2:contains('Pricing')"
  - skill: structured_output
    params:
      schema:
        plan_names: array
        prices: array
        currency: string

Custom skills are versioned, tested, and available to all agents in your account. When a skill is updated, all agents using it pick up the new version on their next cascade run.

Flows

A Flow is an ordered sequence of skills, conditions, and branching logic — a reusable multi-step process that can be embedded into a cascade step.

Where a cascade defines when something runs and what triggers it, a flow defines how a task is executed in detail.

flow: lead_enrichment
description: "Full enrichment flow for a new lead"
steps:
  - name: extract_domain
    skill: spectre_extract
    params:
      url: "$lead.website$"
      depth: standard

  - name: social_lookup
    skill: web_research
    params:
      query: "$lead.company_name$ LinkedIn Twitter leadership"

  - name: structure
    skill: structured_output
    params:
      schema:
        company_summary: string
        tech_stack: array
        recent_news: array
        key_people: array

  - name: write_back
    skill: db_write
    params:
      collection: leads
      id: "$lead.id$"
      data: "$structure.output$"

Flows compose skills into repeatable processes. Once defined, the lead_enrichment flow is available to any cascade step across any agent in your account.

Templates

Templates package cascades and flows for specific use cases — pre-configured workflows you can deploy in minutes rather than building from scratch.

The platform ships with templates for common patterns:

Security Templates

Auto-ban cascade (the landing page demo)
Failed login monitoring and alerting
API abuse detection and rate-limit enforcement

Intelligence Templates

Competitor monitoring with weekly briefing
News feed with AI curation and filtering
Domain research and enrichment pipeline

Outreach Templates

Spectre Email prospect enrichment flow
Cold outreach review queue setup
Follow-up sequence with reply detection

Operations Templates

Project status update automation
Budget monitoring with cascade fallback
Team activity digest (weekly summary of all cascade runs)

A template deploys in one step: choose the template, configure the required parameters (target domains, notification channels, schedule), and save. The full cascade + flows + skills are instantiated in your account, governed by your active laws.

Pro Skill Access

Basic skills are available on all plans. Advanced skills — Spectre integration, custom code execution, multi-model consensus invocation, and the full communication suite — are Pro and Enterprise features.

Skills, flows, and templates form the extensibility layer of the Sovereignty Protocol. The platform ships with substantial built-in capability. But what you can build on top of it — the custom skills tailored to your exact domain, the flows that encode your specific workflows, the templates that package your best practices for your team — is unbounded.

Your AI workforce is as capable as what you equip it with. Start with the built-ins. Build the rest.