What is MCP?

The Model Context Protocol (MCP) is an open standard that lets AI assistants interact with tools and data securely.

MCP bridges the gap between AI models and external systems, enabling AIs to access real-world data and perform actions while maintaining security and privacy.

Key Benefits of MCP:

• Gives AI tools secure, privacy-preserving access to your data
• Standardizes how AI tools connect to apps and services
• Works with any AI model that implements the protocol
• Runs locally on your machine - no data sent to third parties
• Open protocol with permissive licensing

What is Fastn UCL?

The practical implementation of MCP for real-world applications

Fastn UCL makes the Model Context Protocol practical by providing a fully hosted, secure, and scalable MCP server — so your agents can connect to apps like Slack, Jira, Gmail, Shopify, and more without writing custom glue code.

How Fastn UCL Enhances Your AI Capabilities:

• True Multitenancy: Built-in support for multiple tenants with isolated environments - no need for separate instances per customer
• Enterprise-grade Scalability: Handles growing customer bases efficiently without performance degradation
• White-labeled Experience: Present a seamless, branded integration experience for your customers
• Full Integration Control: Complete API access with centralized management
• Centralized Observability: Monitor and analyze all integrations from a single dashboard

Why Fastn UCL is a Game-Changer:

Most AI agents can't do anything useful because they can't access your systems. Fastn UCL solves this by creating a secure bridge between AI and your business applications.

Without Fastn UCL:

AI can only suggest actions, requiring you to manually implement them

→

With Fastn UCL:

AI can directly take action in your systems - update records, send messages, create tickets

Fastn.ai vs Traditional Solutions

How Fastn.ai compares to traditional solutions

	Fastn.ai	Others
Multitenancy	✓ Built-in, true multitenancy	✗ Each user manages own workflow
White-labeling	✓ Full brand control	✗ Not always the case
Scalability	✓ Enterprise-ready , any number of apps under one commad layer	✗ Scales poorly across tenants
SDK / Developer Tools	✓ SDKs & APIs available	✓ Dev platform, but limited embedding
Enterprise Flexibility	✓ Dynamic schema adaptation with fallback strategies and mapping resolution	✓ Rigid static schema mapping; fragile with dynamic data
Analytics & Monitoring	✓ Centralized observability	✗ Minimal usage insights

Why Choose Fastn.ai for Your SaaS:

• Built for Multi-tenant SaaS: Unlike traditional iPaaS solutions that require each end user to manage their own instance, Fastn.ai is designed specifically for SaaS companies needing to manage integrations across all their customers.
• White-labeled Experience: Present a seamless, branded integration experience to your customers without third-party branding interference.
• Enterprise-grade Scalability: As your customer base grows, Fastn.ai scales efficiently without the overhead of managing individual integration accounts.
• Cost-effective: Pricing aligned with SaaS business models prevents integration costs from eating into your margins as you scale.

Use Case: "Send a Message" Workflow

How Fastn UCL simplifies messaging across different platforms

💼 Business Scenario:

You've built a simple messaging workflow in Fastn. Every tenant (customer) just wants to send a notification like:

"Hey, your task is overdue!"

But different customers use different messaging tools:

Customer	Preferred Tool
Customer A	Slack
Customer B	Microsoft Teams
Customer C	WhatsApp

Multitenancy Challenges:

• 🔹Hardcode logic: if customer == A → send_slack()
• 🔹Maintain multiple workflows or agents
• 🔹Manually manage which customer uses which tool

It gets messy fast, especially as you scale.

With Fastn + MCP + Multitenancy:

You build one single "Send Message" workflow.

Then Fastn does the rest:

• ✅Fastn UCL automatically loads the right context
• ✅Workflow picks the correct integration based on tenant
• ✅Message gets delivered to the right channel — no extra logic needed

Behind the Scenes:

Each tenant has their own context:

{ "tenant": "Customer A", "messaging_tool": "slack", "slack_webhook": "https://hooks.slack.com/..." }

{ "tenant": "Customer B", "messaging_tool": "teams", "teams_channel_id": "abc-123" }

Your Fastn workflow uses:

SendMessage(tool=MCP.messaging_tool, content="Task is overdue")

Fastn figures out whether it's Slack or Teams using Fastn UCL context — you don't change a thing.

🧪 Output Example:

Customer A

Sent to Slack: "Task is overdue!"

Customer B

Sent to Teams: "Task is overdue!"

Customer C

Sent via WhatsApp: "Task is overdue!"

✨ Why It's Beautiful:

• 1
  One workflow
• 2
  Zero hardcoding
• 3
  Context-aware
• 4
  Fully multitenant out of the box

Fastn UCL Architecture

Visual overview of how Fastn UCL components interact

Host with Agent

(Claude, Cursor, VS Code, SDK)

Fastn UCL Protocol

Fastn UCL Server

Fastn UCL API

Fastn Connects

Connectors

Google Docs

Slack

Zoho

NetSuite

How Fastn UCL Works:

• 1
  Host with Fastn UCL Client: Programs like Claude Desktop, IDEs, or AI tools that want to access data through Fastn UCL
• 2
  Fastn with Fastn UCL Server: Fastn provides the Fastn UCL Server which exposes specific capabilities through the standardized Model Context Protocol
• 3
  Connectors: Integration points that Fastn connects to for accessing data sources and services
• 4
  Services: External systems available over the internet or local data sources that Fastn can securely access through connectors

How Fastn UCL Works

Step-by-step processes and example scenarios

How Fastn UCL works with your actions

Basic Fastn UCL Flow

1

User Request

User sends a request to their AI assistant (Claude, Cursor, etc.)

2

Fastn UCL Client

The AI assistant uses Fastn UCL to fetch context and data securely

3

Fastn UCL Server (Fastn)

Fastn UCL Host processes the request and calls the appropriate connector

4

Actions Executed

Connectors perform the requested actions with your services

5

Response

Results flow back to the AI assistant who can provide a relevant response

Example Scenarios

Document Management

Ask your AI to update a Google Doc with meeting notes

"Update our quarterly goals document with the summary from today's meeting"

Data Analysis

Request your AI to analyze data from Google Sheets

"Create a chart from our sales data in the Q2 spreadsheet"

CRM Management

Ask your AI to set a meeting with HubSpot contacts and share on Slack

"Schedule a 15-minute deployment meeting with all HubSpot contacts in 2 hours and send the link on Slack"

Email Management

Ask your AI to manage your Gmail account

"Draft a Gmail to johnsmith@gmail.com with our Q2 analytics report attached"

Fastn UCL Server

A dedicated Fastn UCL Server implementation that connects AI tools to your applications and data

Fastn UCL Server is a robust implementation of the Fastn UCL standard that acts as a bridge between AI assistants and your data sources. It provides secure, controlled access to your applications while keeping your data private.

Key Features of Fastn + Server:

• Pre-built connectors for popular services like Google Docs, Slack, Notion, and more
• Custom connector support for connecting to any API or service
• Secure authentication and access control
• Runs locally, ensuring your data remains private
• Easy setup and configuration

What is Multitenancy in Fastn?

How Fastn handles multiple customers with isolated environments

Multitenancy lets you serve multiple customers (tenants) through a single Fastn UCL instance — while keeping their data, apps, and actions fully isolated. Whether you're powering internal teams or external clients, Fastn ensures every tenant gets their own secure, customized command layer.

Why It Matters:

• Isolated Execution: Keep workflows, credentials, and audit logs tenant-specific — no cross-bleed.
• Built-in Access Control: Enforce tenant-level auth and permissioning out of the box.
• One Deployment, Many Customers: Scale effortlessly — no need to spin up separate infrastructure.
• Custom App Connections per Tenant: Each tenant connects their own tools — Fastn handles the routing.

Real-World Example:

You say: "Notify Users"

Fastn UCL knows:

• Customer A uses Slack → sends Slack notification
• Customer B uses Microsoft Teams → sends Teams notification

You don't write if-else logic.
Fastn auto-routes based on tenant config.

Common Use Cases:

• SaaS platforms with enterprise customers
• Marketplaces supporting vendors or stores
• Internal command layers with department-level routing
• AI agents responding to different client data pipelines

Security, by Design

Fastn enforces strict tenant isolation via secure APIs and workspace-scoped tokens. Tenant IDs are validated on every request. No accidental leaks. No tenant-hopping.

Multitenancy Architecture:

Learn More

Explore these resources to deepen your understanding of Fastn UCL

Fastn UCL Official Website

The official Fastn UCL documentation and resources

Fastn UCL GitHub Repository

Source code and implementation details