10 Best MCP Gateways for Developers in 2026: A Deep Dive Comparison

AI agents have moved from labs to production, and developers are running into a wall. When you try to connect agents to dozens of external tools and APIs, you face the "N×M problem". Every agent needs to handle connections, credentials, and policies for every tool. Your system becomes brittle, insecure, and impossible to manage.

The industry has converged on the Model Context Protocol (MCP), an open standard that defines how agents and tools communicate. But the protocol itself won't solve your production problems. You need a control plane that manages this communication securely at scale. The MCP Gateway serves as critical infrastructure between your agents and tools.

This guide breaks down the MCP Gateway landscape from a developer perspective. We'll evaluate the top solutions for 2026 and give you a framework for choosing the right one for your architecture.

Key Takeaways

• What is an MCP Gateway? It's essential infrastructure for production AI. An MCP Gateway acts as a central control plane between AI agents (like LangChain or CrewAI) and external tools (APIs), solving the complex "N×M" integration problem.

• Why is it Critical? A gateway centralises agent-tool communication to provide security (managing all credentials), observability (with OpenTelemetry), cost control (rate limiting), and governance (RBAC).

• How to Choose the Best Gateway: Your choice depends on what matters most: performance (p95 latency), security (OAuth 2.1, PII redaction), developer experience, and integration breadth.

• The Default Choice for Most Teams: Composio is the most balanced, developer-first option for production. It combines 500+ deep, managed integrations, unified auth, and low-latency performance, so you don’t have to trade off speed for integration depth.

• Specialised Alternatives for Narrow Needs:

  • Ultra-Low-Level Performance: TrueFoundry, if you've a platform team and you’re willing to trade integration velocity for marginal p95 latency gains.

  • High-Security & Compliance: Lasso Security (threat detection) or MintMCP (compliance-first governance).

  • Max Breadth for Business Apps: Zapier (8,000+ apps) or Workato (12,000+ apps), especially if you’re already invested in those ecosystems.

• Open-Source Options Exist: Teams needing full data control should look at Docker MCP Gateway and Obot, the top open-source, self-hosted solutions.

• Avoid the DIY Trap: Building your own production-grade gateway is a false economy. The cost of maintaining security, authentication (OAuth), and resilience makes managed solutions a better investment.

Our Recommendation
For 90% of real-world teams, Composio is a strictly better default than niche or open source solutions like TrueFoundry, Lasso Security or MintMCP. You get low latency plus 500+ managed integrations, unified OAuth, and production-grade RBAC/PII controls out of the box, without building or maintaining your own tool layer. Use niche or open source gateways only when you have a dedicated platform team and a very narrow requirements.

How to Choose the Best MCP Gateway: Key Decision Criteria

Evaluating MCP Gateways requires a technical checklist. The right solution depends on your priorities, but every production system should be assessed against these criteria.

• Deployment Model (Managed vs. DIY)
  First, decide whether to build your own gateway or use a managed service. A DIY gateway gives you maximum control but also imposes a high maintenance burden and significant security responsibilities. Managed platforms offer lower total cost of ownership (TCO), enterprise-grade security, and high reliability. For most production use cases, managed services make more sense.

• Performance & Latency
  Every millisecond, the gateway directly impacts user experience, especially for conversational AI. You want gateways optimised for high throughput and low overhead. Key metrics include p95 latency (the 95th percentile latency, reflecting the typical user-experienced delay) and requests per second (RPS). For most enterprise applications which are not conversational, a low-latency solution works well, especially if it gives you velocity.

• Security Posture
  Security isn't optional. A production gateway must support modern authentication standards, such as OAuth 2.1 with PKCE. Look for features such as PII redaction to prevent sensitive data exposure in logs or to agents, and the ability to enforce fine-grained, tool-level permissions.

• Developer Experience (DX) & Ecosystem
  A great gateway doubles as a great developer platform. Check the quality of documentation, SDKs, and CLI tools. Strong developer experience speeds up development and simplifies operations. The breadth of the ecosystem, particularly pre-built integrations, can significantly accelerate development.

• Integration & Interoperability
  The MCP landscape continues evolving. A good gateway should support different MCP specification versions and transports (like stdio and streamable HTTP). The ability to connect existing REST APIs and "virtualise" them as MCP servers helps with migration.

Integrating with Your Agentic Framework

An MCP Gateway isn't standalone. It must integrate smoothly with the frameworks you use to build agents, such as LangChain, CrewAI, or LlamaIndex. The core integration pattern configures your agent's tool-loading mechanism to point to the gateway's single endpoint rather than connecting to each tool individually.

This abstracts the tool discovery and authentication complexity from the agent's core logic. The agent requests available tools from the gateway and invokes them through that same endpoint.

Here's a practical example showing LangChain agent integration with an MCP Gateway using the Composio SDK. This pattern replaces individual tool connections with a unified toolset.

# 1. Installation
# pip install composio-langchain langchain langchain-openai python-dotenv
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import create_agent

# Import the Composio client and LangChain provider
from composio import Composio
from composio_langchain import LangchainProvider

# 2. Environment Setup
# Load environment variables from a .env file (create one with your keys)
# OPENAI_API_KEY="sk-..."
# COMPOSIO_API_KEY="your-composio-api-key"
load_dotenv()

# Ensure API keys are set from environment variables for security
if not os.getenv("COMPOSIO_API_KEY") or not os.getenv("OPENAI_API_KEY"):
    raise ValueError("COMPOSIO_API_KEY and OPENAI_API_KEY must be set in your environment.")

# 3. Initialize LLM and Composio Client
# Initialize the language model
llm = ChatOpenAI(model="gpt-4-turbo-preview", temperature=0)

# Initialize the Composio client with LangchainProvider
# This acts as the MCP Gateway client, handling authentication and tool execution
composio_client = Composio(provider=LangchainProvider())

# In a real application, this would be the unique ID of your authenticated user
USER_ID = "<USER-ID>"

# Fetch tools for the 'github' and 'jira' toolkits
try:
    composio_toolset = composio_client.tools.get(user_id=USER_ID, toolkits=["github", "jira"])
except Exception as e:
    print(f"Error fetching tools: {e}")
    composio_toolset = []

# 4. Create the LangChain Agent
# Create the agent using the new LangChain 1.0 API
agent = create_agent(
    model=llm,
    tools=composio_toolset,
    system_prompt="You are a helpful assistant that uses tools to answer questions."
)

# 5. Run the Agent
# The agent now makes all tool calls through the Composio gateway.
# This single interface handles authentication, routing, and execution for all tools.
task = "Find the most recent open issue in the 'composio-python' repository on GitHub and create a corresponding ticket in Jira."
try:
    result = agent.invoke({"messages": [{"role": "user", "content": task}]})
    print("Agent execution result:")
    print(result["messages"][-1]["content"])
except Exception as e:
    # Proper error handling for production-ready code
    print(f"An error occurred during agent execution: {e}")

The composio_client acts as the client to the MCP Gateway. It discovers available tools (like GitHub and Jira) and provides them to the LangChain agent in a compatible format. All tool calls from the agent route through the Composio gateway, which manages authentication, execution, and observability.

This decouples agent logic from the specifics of each tool's API. You can manage your tool ecosystem centrally without redeploying agents.

Decision Matrix: Which Gateway Fits Your Use Case?

Before examining individual products, map your primary use case to the gateway that fits best. This matrix guides your trade-offs based on team priorities.

The Top MCP Gateways for 2026: A Detailed Comparison

The managed MCP Gateway market has matured quickly with several strong contenders. Each takes a different approach and excels in different areas. Here's what you need to know about the top solutions for 2026.

Composio

Throughout this guide, we treat Composio as the default managed gateway for most teams, with other products filling more specialised roles.

• Best For: Rapid development and teams needing to integrate with a wide variety of tools out of the box.

• Overview: Composio is an agentic integration platform that provides an MCP Gateway to dramatically accelerate development. It operates as an aggregator, offering a single, unified endpoint to a vast library of pre-built, managed tool integrations.

• Key Features:

  • 500+ Managed Integrations: An extensive library of pre-built and maintained connectors for popular SaaS applications like Slack, GitHub, Jira, and more.

  • Unified Authentication Layer: Abstracted authentication handles the complexity of OAuth, API keys, and other credential types for every tool, so developers don't have to.

  • Developer-First Experience: Designed to get developers from idea to production quickly with a focus on ease of use and a rich toolset.

• Performance Snapshot: Optimised for low latency, ensuring responsive agent interactions.

• Pros & Cons:

  • Pro: The massive library of managed integrations can save thousands of hours of development time.

  • Pro: The unified authentication layer is a powerful feature that solves a central pain point in tool integration.

  • Con: As a managed platform, it offers less control over the underlying integration infrastructure compared to a DIY or self-hosted solution.

TrueFoundry

• Best For: Platform teams that want to squeeze every millisecond out of the gateway layer and are prepared to own most MCP tool integrations in-house.

• Overview: TrueFoundry focuses on providing a narrow high-performance gateway that unifies management of both LLM calls and MCP tool interactions. Its philosophy centres on providing one integrated control plane for all AI infrastructure, reducing complexity and operational overhead.

• Key Features:

  • Unified LLM & Tool Gateway: Manage access, routing, and observability for both language models and MCP tools from a single dashboard.

  • High-Performance Architecture: Built on an optimised Node.js backend with in-memory policy enforcement for minimal latency.

  • Built-in Observability: Provides detailed, real-time logs, metrics, and traces out of the box for all traffic.

• Performance Snapshot: Adds less than 5ms of p95 latency overhead, making it one of the fastest gateways available.

• Pros & Cons:

  • Pro: Exceptional performance and low latency are ideal for real-time applications.

  • Pro: The unified control plane simplifies AI infrastructure management.

  • Con: Requires building or onboarding most MCP servers yourself. Over time, this becomes a parallel integration program (security reviews, OAuth setups, upgrades) that many product teams underestimate.

  • Con: Strong for infra and routing, but does not provide the “10k+ tools out of the box” experience that Composio’s managed library does – you need more engineering to reach the same integration surface area.

  • Con: Best suited for organisations that already run a centralised platform/infra team. For smaller teams or product-led orgs, the operational load is usually higher than a managed gateway like Composio.

Lunar.dev MCPX

• Best For: Enterprises needing strong governance and robust, managed control over tool access.

• Overview: Lunar.dev MCPX is a lightweight, unified gateway that orchestrates and secures the entire MCP ecosystem. It's designed for enterprises that need a single control point for all agent-to-tool interactions, emphasising security and auditability.

• Key Features:

  • Granular Access Control: Enforce detailed policies to control which tools and methods are accessible to which agents.

  • Comprehensive Audit Logs: Tracks every agent action in an immutable audit trail, providing full visibility for compliance and security reviews.

  • Centralised Secret Management: Stores all secrets, API keys, and OAuth tokens in a single location, enhancing security.

• Performance Snapshot: Excellent performance with a p99 latency overhead of around 4ms.

• Pros & Cons:

  • Pro: Strong focus on enterprise-grade governance and security features.

  • Pro: High performance ensures that security controls don't compromise user experience.

  • Con: More focused on the control and governance layer than on providing a broad library of pre-built tool integrations.

Lasso Security MCP Gateway

• Best For: Regulated industries or applications where security is the absolute top priority.

• Overview: Lasso Security provides an open-source, security-first MCP Gateway. Its plugin-based architecture inspects traffic in real time to detect and mitigate threats such as prompt injection, command injection, and sensitive data exposure.

• Key Features:

  • Real-time Threat Detection: A plugin connects to Lasso's API to check content for security violations, blocking malicious payloads before they reach the agent or tool.

  • PII Masking & Redaction: Automatically detects and masks Personally Identifiable Information (PII) and other secrets in both requests and responses.

  • Tool Reputation Analysis: Scans MCP servers before they are loaded, calculates a reputation score, and blocks risky tools.

• Performance Snapshot: Deep security scanning adds a noticeable 100-250ms of latency overhead.

• Pros & Cons:

  • Pro: Unmatched security features provide the strongest protection for sensitive applications.

  • Pro: The plugin-based architecture is flexible and extensible.

  • Con: The significant performance trade-off makes it unsuitable for latency-sensitive applications.

Docker MCP Gateway

• Best For: Container-native teams and developers who value an open-source, ecosystem-centric approach.

• Overview: The Docker MCP Gateway is an open-source project that integrates with the Docker ecosystem. It runs MCP servers as isolated Docker containers, using familiar container security models and a "Compose-first" workflow.

• Key Features:

  • Docker Ecosystem Integration: Deep integration with Docker Desktop and Docker Compose provides an excellent local development experience.

  • Container-based Security: Leverages container isolation, signed images, and Docker's secret management for a robust and familiar security model.

  • CLI-driven Workflow: A powerful docker mcp CLI plugin allows for easy management of the gateway and server lifecycle.

• Performance Snapshot: Moderate performance, with container management adding 50-200ms of latency overhead.

• Pros & Cons:

  • Pro: Excellent developer experience for teams already invested in the Docker ecosystem.

  • Pro: Open-source and community-driven, offering transparency and flexibility.

  • Con: Performance is not on par with specialised, high-performance gateways like TrueFoundry or Lunar.dev.

MintMCP

• Best For: Regulated industries (healthcare, finance) requiring strict compliance and auditability.

• Overview: MintMCP is a governance-first gateway laser-focused on security and compliance. It's built for organisations blocked from AI adoption by regulatory hurdles, providing the ironclad security posture and audit trails needed to move to production.

• Key Features:

  • Audit-Ready Compliance: Generates logs in SOC 2, HIPAA, and GDPR-compliant formats, providing an exportable audit trail for every request.

  • Federated SSO & RBAC: Integrates with enterprise IdPs (SAML/OIDC) to enforce fine-grained, role-based access controls.

  • Centralised Credential Management: Secures all credentials and provides real-time guardrails to block risky agent actions.

• Performance Snapshot: As a security-first layer, it prioritises deep inspection and logging over raw p95 latency.

• Pros & Cons:

  • Pro: Best-in-class for enterprises in regulated industries.

  • Pro: SOC 2 Type II compliant, providing a significant head start on security reviews.

  • Con: A "Bring-Your-Own-Server" model. It governs tools but doesn't provide a pre-built integration library.

Unified Context Layer (UCL)

• Best For: Developers and SaaS companies needing an all-in-one PaaS to build, host, and scale agents with a large tool library.

• Overview: UCL is a "Vercel-for-MCP" style platform that combines a developer-friendly hosting experience with a massive tool library and enterprise-grade security. It provides a "zero maintenance" infrastructure, allowing teams to focus on building agents rather than managing infrastructure.

• Key Features:

  • All-in-One PaaS: A fully managed platform for hosting, deploying, and scaling MCP servers.

  • Large Integration Library: Includes over 1,000 pre-built tools that combine the "build" (PaaS) and "buy" (iPaaS) models.

  • Multi-Tenant & Compliance-Ready: Designed for SaaS applications with multi-tenancy by default. SOC 2, ISO, and HIPAA/PCI ready.

• Performance Snapshot: Built for production scale, offering a 99.9% Uptime SLA.

• Pros & Cons:

  • Pro: Excellent hybrid of a developer PaaS and a large integration library.

  • Pro: Top-tier security and compliance, ideal for building AI-native SaaS products.

  • Con: Less focused on governing existing, on-prem tools compared to pure-play governance gateways.

Zapier

• Best For: Prototyping and SMBs needing to connect agents to the broadest possible range of apps with minimal setup.

• Overview: The automation giant Zapier has entered the MCP space by exposing its massive ecosystem as a gateway. It provides a simple, secure MCP endpoint that enables agents to access its 8,000+ app integrations, making it an incredibly powerful tool for rapid development.

• Key Features:

  • Unmatched App Breadth: Provides instant MCP access to over 8,000 applications, the largest library on the market.

  • Simple Setup: Developers can generate a secure MCP URL and expose their chosen "Zapier Actions" in minutes.

  • Built-in Authentication: Leverages Zapier's existing, user-managed authentication for all connected apps.

• Performance Snapshot: Designed for simplicity and breadth, not for high-performance, low-latency workloads.

• Pros & Cons:

  • Pro: Unbeatable for breadth of integrations.

  • Pro: Leverages a familiar platform that many teams already use.

  • Con: The task-based pricing (e.g., one tool call = two tasks) can become expensive and unpredictable with "chatty" agents.

Workato

• Best For: Enterprises already using Workato and needing to expose their existing, governed automations to AI agents.

• Overview: Like Zapier, Workato is a leading enterprise iPaaS (Integration Platform as a Service) that has adapted its platform for the agentic era. Its value is not a new gateway, but its mature, enterprise-grade platform that can now expose its 12,000+ app connectors and automation "recipes" via a secure MCP endpoint.

• Key Features:

  • Massive Enterprise Library: Provides MCP access to over 12,000 enterprise applications, all running on its governed runtime.

  • Enterprise-Grade Governance: Leverages Workato's proven, auditable, and secure iPaaS infrastructure, which is a key requirement for many large companies.

  • Low-Code "Recipes": Existing automation recipes can be turned into MCP servers with a few clicks, instantly enabling AI for complex business processes.

• Performance Snapshot: Prioritises governance, auditability, and breadth over the raw p95 latency of a pure-play gateway.

• Pros & Cons:

  • Pro: The ultimate solution for enterprises already heavily invested in the Workato ecosystem.

  • Pro: Unlocks a massive, pre-built, and battle-tested library of enterprise (not just SMB) applications.

  • Con: A high-TCO, enterprise-first platform not intended for individual developers or startups.

Obot

• Best For: Teams that want full data control and a self-hosted, open-source solution.

• Overview: Obot is a powerful, open-source MCP gateway designed for self-hosting. It provides a central control plane that runs on your own infrastructure (e.g., Kubernetes), giving you complete control over your data and security. It's the go-to choice for organisations that prioritise avoiding vendor lock-in.

• Key Features:

  • Open-Source & Self-Hosted: The core platform is open-source and can be deployed on any Kubernetes cluster.

  • Enterprise IdP Support: The enterprise edition integrates with Okta, Microsoft Entra, and other IdPs for policy-based access.

  • Hybrid Tool Model: Includes a library of popular MCP servers (Slack, GitHub, etc.) and allows you to host or proxy your own.

• Performance Snapshot: Performance is dependent on your hosting infrastructure, but the architecture is designed for modern, container-native stacks.

• Pros & Cons:

  • Pro: Open-source gives you maximum control, transparency, and no vendor lock-in.

  • Pro: Fits perfectly into existing Kubernetes and DevOps workflows.

  • Con: As a self-hosted solution, you are responsible for maintaining, scaling, and securing the infrastructure.

A Note on Public Registries: Smithery

It's important to distinguish between the managed gateways listed above and public registries.

Smithery is the leading example of a public registry, acting as a "Docker Hub for MCP." It lists over 2,500 community-built, open-source tools.

• Best For: Experimentation, discovery, and prototyping.

• Production Warning: Smithery is not a managed, enterprise-grade gateway. The tools are community-submitted and unvetted, meaning they lack the security, governance, and reliability (SLA) required for production systems.

A core function of production gateways like Lasso or MintMCP is to prevent agents from connecting to unvetted public endpoints, such as those on Smithery.

At-a-Glance: MCP Gateway Feature Comparison

This table provides a scannable summary of the key differentiators for each gateway.

Composio vs TrueFoundry: Which MCP Gateway Should You Choose?

A common question we hear from developers is how to choose between Composio and TrueFoundry. Here is a simple framework:

When Composio wins (most teams)

• You want to go from idea → production quickly with 500+ managed integrations and zero DIY tool plumbing.

• You care about unified OAuth, RBAC, and PII redaction out of the box.

• You want a single MCP gateway plus integration platform, not just a gateway.

When TrueFoundry can make sense (niche)

• You already have internal MCP servers and governance workflows and just need a very fast control plane.

• You have a dedicated platform/infra team that treats the gateway and tool layer as core infra, not a product feature.

Our recommendation:

Unless you are a large, infra-heavy org that has already invested in its own MCP tool layer, Composio is the safer, faster path to production. It gives you reliable performance plus a mature integration library; for most teams that’s far more valuable than shaving a few milliseconds off gateway latency.

The DIY Trap: Why Building Your Own MCP Gateway is a False Economy

Many engineering teams instinctively want to build their own solution. A simple reverse proxy routing MCP traffic looks straightforward.

But while you can quickly prototype a basic DIY gateway, this approach becomes expensive for any serious production system.

The initial build deceives you. The real cost comes from the specific, difficult engineering problems you must solve for production readiness. A robust gateway requires:

• A Secure Credential Store: An encrypted database for storing OAuth tokens and API keys, complete with automated key rotation and fine-grained access policies.

• A Distributed Rate-Limiting System: A high-performance system that enforces limits accurately across globally distributed gateway instances.

• Robust OAuth 2.1 Client Logic: The complex state machines and cryptographic operations (like PKCE) required to securely authenticate with dozens of different external API providers.

• A PII Redaction Engine: A system to inspect all inbound and outbound traffic in real-time to detect and scrub sensitive data from logs and agent responses.

• Resilience Patterns: Production-grade implementations of circuit breakers, request retries with exponential backoff, and per-tool timeouts to handle failing external APIs gracefully.

• A Dynamic Configuration System: The ability to update routing rules, security policies, and tool definitions without requiring a full deployment or causing downtime.

Each represents a complex distributed systems problem. Building them from scratch requires massive, ongoing engineering investment that distracts from your core product.

For production applications, the TCO, security risks, and operational burden make managed solutions a significantly better investment.

Conclusion: Making the Right Choice for Your Agentic Architecture

An MCP Gateway isn't optional anymore. It's essential infrastructure for building, scaling, and securing production-grade AI agents. It provides the central control plane you need to manage complex interactions between agents and external tools.

The right gateway aligns with your team's primary use case and technical priorities. The landscape offers clear choices for different needs.

• For Developer-First Integration and as the Default Choice: Composio provides the quickest path with deep, managed integrations, low latency and a unified auth layer that works for most production teams.

• For Peak Latency Optimisation in Narrow Use Cases: TrueFoundry offers the lowest overhead when you’re willing to build and maintain your own integrations.

• For Unmatched Security & Compliance: Lasso Security provides real-time threat detection, while MintMCP is the top choice for regulated industries needing SOC 2 and HIPAA-ready audit logs.

• For Maximum Breadth and Linear Workflows: Workato and Zapier offer instant access to 8,000+ and 12,000+ apps, respectively, for enterprises and SMBs.

• For an All-in-One PaaS: Unified Context Layer (UCL) combines a "Vercel-for-MCP" developer experience with 1,000+ tools and multi-tenant security.

• For Open-Source & Self-Hosted Control: The Docker MCP Gateway is the natural fit for Docker-native teams, while Obot provides a powerful, Kubernetes-native solution for full data control.

Choosing the right gateway is a foundational architectural decision. When you invest in a solid control plane, you create a secure, observable, and scalable foundation for building the next generation of intelligent, agentic applications.

Frequently Asked Questions

What are the differences between popular MCP Gateways like TrueFoundry, Composio, Lunar.dev, and Lasso Security?

Each one specialises in a different area:

• Composio focuses on rapid development and integration breadth. It provides 500+ managed integrations and a unified authentication layer to get agents into production quickly.

• TrueFoundry focuses on peak performance. It's built for speed (adds less than 5ms of latency) and unifies the management of both LLM and tool calls.

• Lunar.dev MCPX focuses on enterprise governance. It provides granular, tool-level Role-Based Access Control (RBAC) and comprehensive audit logs for enterprises that need strict control.

• Lasso Security focuses on maximum security. It provides real-time threat detection, PII redaction, and prompt injection defence. Perfect for high-compliance or regulated industries.

Are there open-source MCP Gateway options for self-hosting and full data control?

Yes, there are several solid open-source options.

The Docker MCP Gateway works great for container-native teams. It integrates directly with the Docker ecosystem and uses a familiar "Compose-first" workflow.

Obot is Kubernetes-native and designed for self-hosting. You get full control over your data and infrastructure.

Lasso Security also offers an open-source, security-first gateway if you need both control and strong security features.

What monitoring and observability tools are integrated with MCP Gateways?

Production-grade MCP Gateways integrate with standard observability stacks you're already using:

• Metrics: Export in Prometheus format for your existing dashboards

• Logs: Ship structured logs to Datadog, Splunk, or the ELK stack

• Traces: Support OpenTelemetry (OTel) for distributed tracing, which you'll need for debugging multi-step agent tasks

Is TrueFoundry better than Composio as an MCP Gateway?

Short answer: No, not for most teams.
TrueFoundry is a strong choice if you’re an infra-heavy organisation that wants to own its own MCP servers and is optimising purely for gateway latency. Composio is a better fit for most developer and product teams because it combines a high-performance MCP gateway with 500+ managed integrations, unified OAuth and RBAC, and a zero-data-retention architecture, so you can ship agentic features much faster while maintaining strong security.