MCP, Connectors & Pipelines: Extending Your AI Workforce

The Integration Layer

An AI platform that runs in isolation is limited by what it can see and do. The Sovereignty Protocol's integration layer — MCP, Connectors, and Pipelines — extends the platform's reach in both directions: inward (external tools can call your agents) and outward (your agents can call external tools).

Model Context Protocol (MCP)

MCP is Anthropic's open standard for exposing tools and data sources to AI models. The Sovereignty Protocol implements an MCP server that exposes your entire agent workforce as a tool set accessible to any MCP-compatible client.

What This Means Practically

If you use Claude Desktop, VS Code with AI extensions, or any other MCP client, you can connect it to your Sovereignty Protocol instance. Once connected, your AI client can invoke your Nexus Cascades, query your agent memory, access your Spectre data, and read your Nexus Reports — all through the standard MCP tool interface.

You are not limited to using the platform dashboard. Your AI workforce is accessible from wherever you work.

Available MCP Tools

The platform exposes MCP tools including:

Cascade Tools

run_cascade — Trigger a named cascade by ID, with optional parameter overrides
get_cascade_status — Poll the status of a running cascade
list_cascades — Enumerate all available cascades with their descriptions

Agent Tools

chat_with_agent — Direct conversation with a named agent persona
ask_librarian — Research a topic with the Librarian agent
run_security_check — Invoke the Cipher agent on a specific target

Data Tools

query_nexus_reports — Search your reports history with natural language
get_agent_memory — Retrieve relevant memories for a given context
write_agent_memory — Store a fact or context for future agent recall

Spectre Tools

crawl_url — Extract content from a URL on demand
get_campaign_results — Retrieve the latest results from a named Spectre Campaign
check_domain_health — Run a Domain Suite link health check

Task Tools

create_task — Add a task to the Nexus Tasks board
update_task — Move a task between columns or update its status
list_tasks — Query the current task board

Configuring MCP

From the platform settings, generate an MCP server URL and API key. In your MCP client:

{
  "mcpServers": {
    "sovereignty-protocol": {
      "url": "https://your-instance.com/mcp",
      "apiKey": "your_api_key_here"
    }
  }
}

Your platform's full tool set is now available in your client.

Connectors

Connectors are pre-built integrations with external services, allowing cascade steps to read from and write to third-party platforms without custom HTTP configuration.

Available Connectors

Communication

Slack — Post messages, create channels, read channel history
Discord — Webhook notifications, bot messaging
Microsoft Teams — Adaptive card notifications
Email (SMTP) — Sovereign Mail integration + external SMTP

Project & CRM

GitHub — Create issues, comment on PRs, read repository data
Linear — Create and update issues, set priority and assignee
Notion — Read and write Notion pages and databases
HubSpot — Create contacts, update deal stages, log activities
Airtable — Read and write Airtable bases

Data & Storage

Google Sheets — Read and write spreadsheet data
Google Drive — Read files, create documents
Dropbox — File read/write
AWS S3 — Object storage read/write

Developer Tools

Webhook — Generic inbound and outbound webhook handling
REST API — Configurable HTTP connector for any REST service

Each connector handles authentication (OAuth, API key, or service account) once at setup. After that, cascade steps reference the connector by name:

- name: update_linear_issue
  type: connector
  connector: linear
  action: update_issue
  params:
    issue_id: "$trigger.issue_id$"
    status: "done"
    comment: "$agent_output.summary$"

No authentication logic in the cascade definition — credentials live in the Sentinel Vault, the connector handles the API details.

Pipelines

A Pipeline is a reusable integration pattern that connects two or more connectors with transformation logic.

Where a cascade is a full automation workflow with triggers, scheduling, and agent steps — a pipeline is a lighter-weight data flow between services.

Example: GitHub Issue to Linear Sync

pipeline: github_to_linear
description: "Sync new GitHub issues to Linear"
trigger:
  connector: github
  event: issue.opened
  filter: "label == 'bug'"

steps:
  - transform:
      title: "$github.issue.title$"
      description: "$github.issue.body$"
      priority: "high"

  - connector: linear
    action: create_issue
    data: "$transform$"

  - connector: github
    action: add_comment
    issue_id: "$github.issue.number$"
    body: "Synced to Linear: $linear.issue.url$"

Pipelines run at webhook speed — milliseconds from trigger to completion. They are not cascade-powered (no agent steps, no laws enforcement) — they are pure data flow between connected services.

For integration patterns that need agent reasoning, use a cascade. For integration patterns that are pure data transformation and routing, use a pipeline.

MCP as a Multiplier

The combination of MCP, Connectors, and Pipelines makes the Sovereignty Protocol a hub rather than a silo.

External AI clients (Claude Desktop, Cursor, custom LLM workflows) can invoke your agents via MCP. External services (GitHub, Slack, Linear) can trigger your cascades via Connectors. Your cascade outputs can flow to any external service via Connectors.

Your AI workforce does not live only in the platform dashboard. It is accessible from everywhere your work happens — and it can reach into every service your business uses.

MCP and Connectors are Pro and Enterprise features.