Everything
You Need
To Know

SwarmSpace is a curated, verified plugin marketplace built for personal AI agents. Where other plugin registries (Anthropic's MCP Registry, AWS Marketplace, Docker MCP Gateway) are built for developers, SwarmSpace is built for agents and end users.

AI agents query SwarmSpace at runtime to discover and acquire new capabilities without human pre-configuration. Think of it as the App Store for the agentic web — curated, trusted, and usable without any technical knowledge.

Every existing MCP marketplace targets developers or enterprises. Anthropic's MCP Registry is a package manager layer for developers. AWS Marketplace requires the AWS ecosystem. Google Cloud AI Agent Marketplace is locked to Google infrastructure. Docker MCP Gateway serves DevOps audiences.

None of them are built for consumer personal AI agents. SwarmSpace fills that gap: consumer-grade UX, privacy-by-design, curated trust tiers, and runtime discovery without CLI, self-hosting, or security configuration.

SwarmSpace works with any personal AI agent that can make HTTP requests and implement MCP (Model Context Protocol). It is the native plugin marketplace for LUMARA, the lifetime personal AI companion. Other MCP-compatible agents can integrate via Firebase callable functions.

Agents query SwarmSpace via Firebase callable functions using natural language. The agent identifies a capability gap, forms a query, and calls the search function. SwarmSpace uses semantic/vector search to return ranked results.

// Firebase callable function: searchPlugins
const result = await functions.httpsCallable('searchPlugins')({
  query: "I need a tool that can analyze PDF invoices and extract line items",
  agent_permission_level: "verified",
  max_results: 5
});

Results include plugin manifests ranked by relevance, trust tier, latency class, and pricing. The agent checks the plugin's trust tier against its own permission level before activation.

Yes — inter-agent plugin recommendation is a first-class use case in SwarmSpace. Every plugin has:

• A stable canonical URL that never changes between versions
• A machine-readable manifest summary parseable by any LLM without reading full documentation
• Structured fields designed to be passed between agents as JSON objects

When one agent discovers a useful plugin, it can pass the canonical URL or manifest summary to another agent. The receiving agent can fetch the full manifest and decide whether to activate the plugin.

Trust tiers govern what data a plugin can receive and what actions it can take:

Verified — Sandboxed, manually reviewed, cryptographically signed. Can receive personal user context with explicit user consent. Highest privilege level.

Community — Open-source, automated scanning passed. No personal user context by default. Agent must request elevated access and obtain user consent.

Agents match their own permission level against the plugin's trust tier before execution. An agent operating in a low-trust context cannot activate a Verified plugin that requests personal context without explicit user authorization.

Plugins are not distributed as executable files. SwarmSpace plugins are:

1. A JSON manifest hosted on SwarmSpace that describes the plugin's capabilities, schema, trust tier, pricing, and auth requirements
2. A live MCP endpoint you host on your own infrastructure (any cloud provider, serverless function, or VPS)

No binaries. No installs. No user-side configuration. When an agent activates a plugin, it calls your endpoint via the MCP protocol. SwarmSpace never touches the data flow during execution.

swarmspace-manifest.json  ← hosted on SwarmSpace (index layer)
https://yourserver.com/mcp  ← your MCP endpoint (execution layer)

Required fields:

{
  "id":             "category.plugin-name.v1",  // stable unique ID
  "name":           "Human-readable name",
  "description":    "Natural language capability description — written
                     for LLMs to parse, not just humans.",
  "version":        "1.0.0",
  "protocol":       "mcp",
  "endpoint":       "https://yourserver.com/mcp",
  "trust_tier":     "verified | community",
  "latency_class":  "fast | medium | slow",
  "pricing":        { "model": "free | per_call | subscription", ... },
  "auth":           "none | api_key | oauth2",
  "data_access":    ["list_of_data_types_requested"],
  "tags":           ["semantic", "tags", "for", "discovery"],
  "canonical_url":  "https://swarmspace.ai/plugins/your-plugin-id"
}

The description field is the most important for discoverability — it is what the vector search engine indexes. Write it as a capability statement: what the plugin does, what inputs it needs, what it returns.

Submit via the SwarmSpace Developer Portal. The process:

Community tier: Submit manifest + open-source repository link. Automated scan + community review queue.

Verified tier: Submit manifest + endpoint + data minimization statement. Manual review, sandbox testing, cryptographic signing. One-time submission fee covers review cost.

Anywhere that can serve HTTPS and handle MCP protocol requests. Recommended options by use case:

Cheapest / fastest to launch: Cloudflare Workers (free tier generous, global edge network, zero cold starts) or Vercel Edge Functions.

Best for compute-heavy plugins: Railway, Render, or Fly.io for persistent containers. AWS Lambda or Google Cloud Run for serverless.

Avoid: Squarespace, Webflow, Wix — these are website builders with no API hosting capability. You need a real backend endpoint.

The golden rule: your endpoint must respond to MCP protocol requests over HTTPS with TLS 1.2+. Latency matters — agents rank plugins partially by latency_class, so a slow endpoint reduces discoverability.

Privacy is enforced at the protocol level, not policy.

• Data minimization: Plugins receive only the minimum data necessary. The manifest's data_access field is a hard declaration — plugins cannot access data types not listed.
• Explicit consent: Personal user context is never passed to a plugin without explicit user consent, regardless of trust tier.
• Cryptographic signing: Verified plugins are cryptographically signed. If a plugin's code changes without re-review, the signature invalidates and the plugin is demoted automatically.

Multiple layers:

Automated scanning: Every submitted plugin runs static analysis for prompt injection patterns, data exfiltration signatures, and suspicious endpoint behavior.

Sandbox testing: Verified plugins are tested in an isolated sandbox before approval. Behavioral analysis flags unexpected data requests.

Runtime trust matching: Agents compare their permission level against plugin trust tier at runtime. Mismatches block execution before any data is shared.

Manifest immutability: Published manifests are cryptographically hashed. Any change to a Verified plugin invalidates its signature and triggers re-review.

Kill switch: SwarmSpace maintains the ability to immediately delist any plugin across all agents if a security issue is discovered post-publication.

Prompt injection — where a plugin attempts to manipulate the agent by embedding instructions in its response — is a primary threat model for SwarmSpace.

Mitigations include:

• Automated static analysis of submitted plugins for known injection patterns
• Response schema enforcement: plugins must return structured data matching their declared output schema, not freeform text
• Sandboxed execution for Verified tier review includes injection attempt simulation
• Integrating agents (like LUMARA) are expected to implement their own response sanitization layer before passing plugin output to the model

No system is 100% injection-proof. We publish our threat model and invite responsible disclosure at security@swarmspace.ai.

Plugin discovery and search is free for agents and users. Individual plugins set their own pricing models, which are declared in the manifest: free, per-call, or subscription. SwarmSpace takes a platform fee on paid plugin transactions.

Developer accounts are free for Community tier submissions. Verified tier review has a one-time submission fee that covers manual review and sandbox testing costs.

SwarmSpace handles billing for paid plugins. When an agent activates a paid plugin, the cost is charged to the user's SwarmSpace account (or their connected AI companion's billing). Developers receive payouts via Stripe on a monthly basis, minus the SwarmSpace platform fee. Pricing details and fee structure are available in the Developer Portal.