Intended Product Update: March 2026

What We Shipped

The first quarter of 2026 has been our most productive yet. Here is a summary of the major features, integrations, and improvements we shipped.

MCP Gateway

The Model Context Protocol (MCP) has rapidly become the standard for connecting AI models to external tools and data sources. MCP defines how models discover tools, request data, and execute actions through a standardized server protocol.

The Intended MCP Gateway sits between MCP clients and MCP servers, adding governance to every MCP tool call. When an AI model calls an MCP tool, the gateway intercepts the request, classifies the intent, evaluates it against policies, and issues an authority token before the tool call proceeds.

The MCP Gateway requires no changes to existing MCP servers. It operates as a transparent proxy that adds governance without modifying the tool implementations. Configuration is a single environment variable change on the MCP client: point the client at the Intended MCP Gateway instead of directly at the MCP server.

For organizations adopting MCP, the gateway provides governance from day one. No custom integration code, no wrapper functions, no SDK changes. The governance layer is invisible to the model and to the tool implementations.

The MCP Gateway supports all MCP transport modes: stdio, HTTP, and Server-Sent Events. It handles tool discovery passively (forwarding the tool list without modification) and tool execution actively (intercepting calls for governance evaluation).

Python SDK

Our TypeScript SDK has been available since launch. The Python SDK extends Intended governance to the Python ecosystem, which is where most AI agent development happens.

The Python SDK provides the same capabilities as the TypeScript SDK: intent submission, decision retrieval, token verification, and audit queries. It supports both synchronous and asynchronous operation, integrating cleanly with asyncio-based applications.

Framework integrations are included for LangChain, PydanticAI, CrewAI, and the OpenAI Agents SDK. Each integration provides a governance wrapper that can be applied to tool functions with a single decorator:

from meritt import governance

@governance.authorize(domain="sdlc")
def deploy_service(service_name: str, version: str):
    # deployment logic
    pass

The decorator intercepts the function call, submits an intent to Intended, and only proceeds if the intent is approved. If the intent is denied or escalated, the decorator raises an appropriate exception.

The Python SDK is available on PyPI and supports Python 3.10 and above.

Kubernetes Admission Controller

AI agents increasingly manage Kubernetes resources: creating deployments, modifying services, scaling workloads, and managing configurations. The Intended Kubernetes Admission Controller brings governance to the Kubernetes API server.

The admission controller is deployed as a ValidatingWebhookConfiguration. It intercepts Kubernetes API requests before they are persisted to etcd, classifies the requested action, evaluates it against Intended policies, and approves or denies the request.

This is enforcement at the infrastructure level. Even if an AI agent bypasses the SDK or ignores the governance decision, the Kubernetes API server will reject the request if the admission controller denies it. The agent cannot work around the governance layer because the enforcement point is in Kubernetes itself.

The admission controller supports fine-grained configuration. You can govern all Kubernetes resources or only specific resource types. You can apply different policies per namespace (useful for separating production from staging). You can exclude system namespaces (kube-system) from governance.

New Pricing Tiers

We restructured our pricing to better align with how organizations adopt governance.

**Starter** (free up to 1,000 decisions per month): For teams evaluating Intended or running small-scale agent operations. Includes the Authority Engine, basic audit, and email support. No credit card required.

**Growth** ($499/month for up to 50,000 decisions): For organizations scaling agent operations across multiple teams. Includes all domain packs, escalation workflows, priority support, and SSO.

**Enterprise** (custom pricing): For organizations with advanced requirements. Includes single-tenant deployment, custom domain packs, SLA guarantees, dedicated support, and compliance evidence exports.

The new pricing removes barriers to adoption. Teams can start with the free tier, prove value, and scale to Growth or Enterprise as their governance needs mature.

Domain Pack Updates

We shipped updates to three domain packs based on customer feedback.

The SDLC domain pack now includes categories for AI-assisted code review, automated testing, and model deployment. These categories recognize that AI agents are not just deploying traditional code -- they are also deploying and managing AI models.

The Infrastructure domain pack added categories for serverless function management, edge compute, and multi-cloud orchestration. These categories reflect the evolution of infrastructure beyond traditional compute and storage.

The SecOps domain pack added categories for threat intelligence enrichment, automated incident triage, and vulnerability prioritization. These categories support the growing use of AI agents in security operations workflows.

CLI Improvements

The Intended CLI received several improvements. The `meritt audit verify` command now supports partial chain verification, allowing you to verify a specific time range rather than the entire chain. This is useful for large chains where full verification takes significant time.

The `meritt policy test` command now supports snapshot testing. You can capture the current behavior of your policy set against a set of test intents and verify that future policy changes do not unintentionally alter outcomes.

The `meritt agent ls` command provides a comprehensive view of all registered agents, their trust levels, and their recent activity. This is useful for quick audits of agent operations from the command line.

Documentation and Community

We published 15 new blog posts covering topics from technical deep dives to industry analysis. Our documentation site received a full refresh with improved search, code examples in both TypeScript and Python, and a new troubleshooting section.

The community Slack channel now has over 500 members, and we are seeing increasing contributions from the community: custom connector implementations, policy templates, and integration guides.

What Is Next

The second quarter of 2026 focuses on multi-agent governance, predictive risk scoring, and additional connector integrations. We are also investing in the console experience, with a redesigned dashboard that provides better visibility into governance operations at a glance.

We will share more details as these features approach release. Follow us on the blog or join the community Slack to stay updated.