Blekline MCP Server

The problem nobody wants to talk about

AI agents are eating the world. Cursor writes your code, Claude answers your support tickets, autonomous pipelines touch your databases, your APIs, your customers' data. The ecosystem is accelerating — MCP servers let agents pick up tools like apps pick up plugins — and that is genuinely exciting.

But here's the thing: your agents have no idea what they're not allowed to do. They'll happily pass an AWS key to a model context window. They'll call a tool with a customer's email as an argument. They'll execute a shell command that wasn't in the plan. Not out of malice — out of the fundamental nature of language models: they optimize for task completion, not for the organizational policies you haven't written yet.

This is the AI governance gap. And right now, there's nothing sitting between your agents and everything they can touch.

Related MCP server: sovr-mcp-proxy

Why this is becoming urgent

The EU AI Act isn't theoretical anymore. GPAI obligations have been enforceable since August 2025. Transparency and human oversight requirements land in August 2026. High-risk system conformity assessments follow. Fines reach up to €35 million or 7% of global turnover for the worst violations. And these rules aren't just about the models — they're about the systems you build with them: how you govern tool access, how you audit decisions, how you prove a human was in the loop.

Meanwhile, enterprises running AI at scale — sandboxed, parallelized, thousands of agent calls — have no native answer for: what happened in that session? Who authorized that tool call? Did any PII leave the context window?

The compliance question is catching up to the capability question. And most teams aren't ready.

What Blekline is

Blekline is an open-core MCP ingress control plane — infrastructure that sits between your agents and everything they can touch.

It does three things, in real time, before any LLM sees a prompt or any tool executes:

Mask — strip PII, secrets, and sensitive context from prompts before they hit model APIs (MCP Server docs)

Enforce — evaluate tool calls against policy; allow, flag, or block before execution

Audit — emit a structured, tamper-evident event trail for every agent interaction

You can run it locally in two minutes. You can deploy it as a sidecar alongside any L1 sandbox (Daytona, Modal, E2B, Cloudflare, Vercel Sandbox). You can plug it into Cursor, Claude Desktop, or Codex today — without changing your agent code.

This is the infrastructure that makes governed AI deployment real: not a checkbox, not a policy document, but a running system that enforces your intentions at the call level.

Start here

pnpm install && pnpm build:packages
export BLEKLINE_WORKSPACE_TOKEN="blw_..."
export BLEKLINE_API_URL="https://app.blekline.com"
export BLEKLINE_CLIENT_SURFACE="sdk"
pnpm demo:mcp-smoke

Headless guide: cli/README.md · CI template: ci/

Connect Blekline

Full index: integrations/README.md · Docs: app.blekline.com/docs

pnpm generate:mcp-configs          # *.example configs
pnpm verify:integrations           # manifest + schema checks

In any client: "Use blekline_mask_prompt on: Contact Jane at jane@acme.com — API key AKIAIOSFODNN7EXAMPLE"

Architecture

Blekline sits at Layer 4 — between L5 agents (Cursor, Claude, Codex) and L1 sandboxes (Daytona, Modal, Vercel Sandbox, Cloudflare, E2B) and model APIs.

L5 Agents → L4 Blekline (mask · enforce · audit) → L1 sandbox MCP / model APIs

AI Enablement Stack · Architecture · Trust boundaries · Latency SLO

Open core vs cloud

License: AGPL for proxy/server (self-host or buy cloud). Apache for contracts/SDK (embed in your agent stack).

Who this is for

Developers building with Cursor, Claude Desktop, or Codex who want their agents to stop leaking secrets and start respecting tool boundaries.

Platform teams deploying AI workloads in L1 sandboxes who need a governance layer that travels with the execution environment.

Enterprise architects preparing for EU AI Act compliance — specifically human oversight, audit trails, and tool call transparency requirements that become enforceable in August 2026.

Open source contributors who believe that the infrastructure for safe AI should be auditable, forkable, and owned by the community — not locked inside a vendor's cloud.

Packages

OpenAPI: packages/contracts/openapi.yaml

MCP tools

Proxy path: agent → Blekline → allow/mask/block → downstream MCP (Daytona, E2B, Modal, Cloudflare, Vercel Sandbox, custom).

Client libraries

TypeScript

npm install @blekline/client

import { BleklineClient } from "@blekline/client";

const blekline = new BleklineClient({
  workspaceToken: process.env.BLEKLINE_WORKSPACE_TOKEN!,
  metadata: { clientSurface: "sdk" },
});

await blekline.mask({ text: "alice@corp.com", platform: "MyAgent" });
await blekline.enforceToolCall({
  toolName: "run_shell",
  arguments: { cmd: "curl https://api.internal/deploy" },
});

Python

pip install blekline-client

Local-only (no API token)

import { enforceToolCallLocally, scanTextForSecrets } from "@blekline/contracts";

scanTextForSecrets("export AWS_KEY=AKIAIOSFODNN7EXAMPLE");
enforceToolCallLocally({
  toolName: "run_shell",
  arguments: { cmd: "export AWS_KEY=AKIAIOSFODNN7EXAMPLE" },
  requestId: "local-1",
});

Works with

Full integration guides on app.blekline.com/docs — not mirrored in this repo.

L5 agent clients

L2 model providers

L2 frameworks & RAG

L3 eval & safety

L1 sandboxes

Deploy

Development

Client demos and smoke tests: demo/README.md.

git clone https://github.com/Blekline/blekline-oss.git && cd blekline-oss
pnpm install && pnpm build:packages && pnpm demo:mcp-smoke

Documentation

All docs: app.blekline.com/docs

Community & design partners

Questions or integration feedback — GitHub Discussions (Q&A, integration feedback).

Design partners — shipping agents in production and want help wiring Blekline into your stack (proxy or MCP server)?

• Open a design partner issue

• Or start a discussion — choose Design partner interest

Contributing

CONTRIBUTING.md · SECURITY.md · CHANGELOG.md

Private Blekline team: develop in the blekline monorepo, run pnpm sync:oss from the root repo.

License

Managed SaaS at app.blekline.com is not licensed under this repository.