Pipe — The MCP-native runtime, production-ready

The first language with built-in MCP — server and client. 249 builtins, single ~8 MB binary. Zero dependencies. Officially listed in the official MCP Registry (v1.1.1, active). One-click install from GitHub MCP Registry for Copilot & VS Code.

What's New in v1.3

Pipe v1.3.0 builds on the multi-agent and vision work from v1.2.0:

• Multi-agent swarms — ai_swarm / ai_swarm_trace / swarm_agent: named agents hand a conversation off to one another via a reserved tool call, with the full message history carried forward. ai_swarm_stream adds live progress observation (tool calls, handoffs, reasoning, round-check callbacks to intervene mid-run) and now runs independent tool calls within a round in parallel where safe.
• ai_vision — ask a question about an image (an http(s) URL, local file, or raw bytes) via an OpenAI-compatible vision model.
• OpenCode Zen AI provider — 6th provider, with free-tier models usable without any API key.
• Built-in self-updater — pipe --update / --update-check fetch, checksum-verify and swap in the latest GitHub release.
• tool_call — direct, LLM-free invocation of a registered tool.
• file_lock / file_unlock — real cross-process advisory file locking.
• elif keyword in if/else chains.
• ai_tool: parallel_safe flag — batches of Pipe-defined fn tools can now run in parallel too, not just builtins.
• pipe -build now supports real multi-file projects, preserving relative subdirectory paths.
• Hardened sandbox — audit rounds 7-11: closed filesystem-write gate gaps, the wiki_search egress gap, an exec_whitelist shell-injection gap, and a hard-link escape.
• 249 builtins — 41 AI + 13 MCP + 195 standard, up from 226 in v0.9.3
• 23 modules — MQTT, SQLite, pipe-http, pipe-web, pipe-orm, pipe-cli, and more

Quick Install

curl -fsSL https://pipe-lang.com/install.sh | bash   # Linux & macOS

Windows (PowerShell): irm https://pipe-lang.com/install.ps1 | iex

The installer downloads the latest release, verifies its SHA256 checksum and installs pipe into ~/.local/bin (or /usr/local/bin when run as root). Pin a version with PIPE_VERSION=v1.0.0. See the full install docs.

Installed copies update themselves against the latest GitHub release: pipe --update (or pipe --update-check to only look, pipe --version to show what you are on). The updater verifies the release checksum and replaces the binary in place.

Privacy & DSGVO

Pipe is DSGVO-konform / GDPR-compliant by design:

• Zero telemetry & analytics — the binary never phones home, nothing leaves your machine
• Self-hosted single binary — runs entirely on your infrastructure
• No cloud — no vendor server processes your data
• Open source (MIT) — fully auditable
• Local AI — with Ollama, not a single byte leaves your network; cloud providers are used only if you configure one

The Problem

Running AI in production is harder than it should be:

• Security — LLMs with file access, network, and exec are a liability. You need fine-grained sandboxing at the language level, not afterthought middleware.
• Performance — Sequential API calls turn a 1-second pipeline into a 10-second bottleneck. Parallelism shouldn't require asyncio.gather() boilerplate.
• Vendor Lock-in — Switching from OpenAI to DeepSeek means rewriting your Python SDK code. Provider changes should be one line.
• Tool Integration — Connecting LLMs to external tools (GitHub, databases, filesystems) is a maze of SDKs and API wrappers. MCP should be a language primitive, not a library.

Pipe fixes this at the language level.

What is Pipe?

Pipe is a Semantic Pipeline Runtime (SPR) — a pipeline-native language where summarize, translate, and classify sit on the same syntax level as +, sort, and len. Data flows top to bottom through composable transformations. One binary. Zero dependencies.

Python + LangChain (~80 lines):

import openai
client = openai.OpenAI()
def summarize(text):
    r = client.chat.completions.create(model="gpt-4o", messages=[{"role":"user","content":text}])
    return r.choices[0].message.content
def translate(text, lang):
    r = client.chat.completions.create(model="gpt-4o",
        messages=[{"role":"system","content":f"Translate to {lang}"},{"role":"user","content":text}])
    return r.choices[0].message.content
text = open("news.txt").read()
print(translate(summarize(text), "de"))

Pipe (5 lines):

read_file "news.txt"
    > summarize       -- LLM call
    > translate "de"  -- LLM call
    > print

Model Context Protocol

Pipe has built-in MCP — both as a server and client. No SDKs, no npm packages, no Python. Pure Go stdlib.

MCP Server — Expose your tools

fn get_weather city
    match city
        | "Berlin" -> "22°C, sunny"
        | "London" -> "15°C, rainy"
        | _ -> city ++ ": no data"

ai_tool "get_weather" "Get weather for a city" {city: "City name"} get_weather
mcp_server "Weather Agent" "1.0.0"
mcp_serve_stdio

Configure in Claude Desktop (claude_desktop_config.json):

{ "mcpServers": { "pipe": { "command": "/tmp/pipe", "args": ["agent.pipe"] } } }

MCP Client — Use external tools

ai_provider "deepseek"
ai_set_key "deepseek" (env "DEEPSEEK_API_KEY")

-- Connect to GitHub + Filesystem MCP servers
mcp_use_stdio "npx" "-y" "@modelcontextprotocol/server-github" {GITHUB_TOKEN: (env "GITHUB_TOKEN")}
mcp_use_stdio "npx" "-y" "@modelcontextprotocol/server-filesystem" "/tmp"

-- AI discovers and uses all tools automatically
result: ai_with_tools "You are a DevOps assistant." "Search pipe's open issues and list files in /tmp." 10
print result

Any stdio MCP server works immediately: Filesystem, GitHub, Git, Postgres, SQLite, Slack, Brave Search, Memory, Sequential Thinking — anything on npm/uvx.

Use Cases

Log Analysis → Incident Report

is_critical: fn line
    contains line "critical"

read_file "/var/log/app/errors.log"
    > split "\n"
    > filter is_critical
    > summarize
    > translate "de"
    > save "incident_report.txt"

RAG Pipeline

ai_provider "deepseek"

docs: read_lines "knowledge_base.txt"
vectors: embed_batch docs

question: "How does the bytecode VM work?"
q_vec: embed question
top: nearest q_vec vectors 3

context: ""
for idx in top
    context: context ++ (at docs idx) ++ "\n---\n"

ask ("Context:\n" ++ context ++ "\nQuestion: " ++ question)
    > print

AI Agent with Tool Calling

fn get_weather city
    match city
        | "Berlin" -> "22°C, sunny"
        | "London" -> "15°C, rainy"
        | _ -> city ++ ": no data"

ai_tool "get_weather" "Get current weather for a city" {city: "Name of the city"} get_weather

ai_with_tools "You are a weather assistant." "What's the weather in Berlin and London?"
    > print

Concurrency — 3 LLM Calls in 1.5s, Not 4s

ai_provider "deepseek"

a: "Explain monads" >> ask
b: "What is CP/M?" >> ask
c: "Explain RFC 791" >> ask

print a ++ b ++ c   -- Future auto-resolution

Discord CI/CD Notifications

import "discord.pipe" as d
ai_provider "deepseek"

-- AI code review per commit, sent as Discord embed
review: ai_chat "Review this code change" diff 800

d.d_webhook_embed (env "DISCORD_WEBHOOK") {
    title: "CI: Push to master",
    color: 3447003,
    fields: [
        {name: "Changed Files", value: stat},
        {name: "AI Review", value: review}
    ]
}

Comparison: Pipe vs Python + LangChain

Features