Enterprise AI control plane

One runtime layer for production agents.

Run agents, attach tools, audit every step, and route approved models through one gateway without changing SDKs.

Open ConsoleRead the API
One endpointPolicy routingManaged tools

Trusted by startups, enterprises, and AI innovators worldwide.

Runtime gateway

Three services. One governed request.

Agent Runtime runs the work, Model Gateway routes approved models, and Audit records every decision.

~/pipellm/control-plane.mjsrequest active

01 / Agent Runtime

Run the agent.

Session state, execution, and agent context stay here.

Sessionsess_checkout_42Tool leasewebsearch attachedStatedurable
Open Runtime Dashboard

Active console

Model Gateway

Open Model Gateway Dashboard
POST

https://api.pipellm.ai/openai

Model GatewayNode.js
const response = await fetch(
  "https://api.pipellm.ai/openai",
  { method: "POST", body: request }
);
OpenAIAnthropicGemini

03 / Audit

Record the decision.

Route, approvals, and tool activity become traceable evidence.

Tracetr_01H9K6Runs4 completedApprovalpolicy passed
Open Audit Dashboard

Managed tools

Configured at the Model Gateway and attached to agent requests when policy allows.

websearch.attach
Current result

✓ approved model selected

Applies policy and routes requests to approved models.
Model gateway

Keep the SDK. Govern every model call.

PipeLLM sits between your application and model providers. Keep familiar client calls, change the base URL, and let the gateway translate protocols, apply policy, and route approved models.

Open Model Gateway

Gateway control path

01

Translate

Keep the client contract your application already uses.

02

Enforce

Apply approved models, provider access, and runtime policy.

03

Route

Select the right approved provider for each model call.

SDK-compatible request

Keep the client. Change the layer underneath.

Keep the familiar OpenAI client and route it through PipeLLM to reach approved models.

1
|

Gateway decision

ProtocolOpenAI SDKPolicyapprovedRouteprovider selected
PipeLLM runtime

One runtime layer for production agents.

Managed tools, policy controls, approval trails, and operator visibility without turning the page into a wall of dashboard copy.

View the platform docs
~/runtime/agent-session.mjssession live

Agent Runtime SDK

Run the agent. Keep the context.

One runtime call keeps execution, session state, and managed tools attached for the whole run.

import { runtime } from "@pipellm/runtime";

const run = await runtime.run({
  agent: "support-triage",
  session: "sess_checkout_42",
  tools: ["websearch"]
});
policy applied before executiontrace opens with the run
Sessionsess_checkout_42state retained
Tool leasewebsearch.attachpolicy allowed
Operator viewapproval trailtrace ready
Runtime audit

Decisions you can replay.

See what happened, why it was allowed, and what evidence stays with the outcome.

~/audit/tr_01H9K6.json
4 eventsproduction
Decision replay00:03.612
Selected decision03 / 04

A policy gate asks for review.

The requested refund exceeded the autonomous limit, so the action paused for an operator.

Trigger
action: refund.create ($286.00)
Policy
refunds over $200 require approval
Outcome
approved by ops
Evidence bundle

Everything needed to explain this decision stays connected to the trace.

  • approver: m.hsu
  • policy: refund.threshold
  • decision: approved
complete and exportable
Trace integrity context, policy, and outcome linkedReplay any decision without reconstructing the run.
Modular pricing_

Pricing that follows the layer you use.

Gateway follows provider pricing. Runtime and Audit combine a platform base with usage. Build Agent is scoped with your team.

View all pricing
01

Gateway

Usage by model

Provider rates, routed through one API.

02

Runtime

Base + usage

Monthly runtime capacity and managed runs.

03

Build Agent

Custom

Scoped development and production delivery.

04

Audit

Base + usage

Monthly retention and recorded events.

Give agents live context.

Call PipeLLM WebSearch from your app, return grounded context, and keep tool access inside the same production control layer.

Explore WebSearch
WebSearch APIExplore all four routesAPI keys and usageOpen Console
const response = await fetch(
  "https://api.pipellm.ai/v1/websearch/search",
  { method: "POST",
    headers: { Authorization: "Bearer " + process.env.PIPELLM_API_KEY },
    body: JSON.stringify({ query: "agent updates" })
  }
);

const { results } = await response.json();

Insights & Resources

Guides, implementation notes, and production patterns for teams building with AI.

Explore Our Blog
Agent memory architecture with semantic recall layers

Agent Memory Is the Next Bottleneck in AI Applications

Bigger context windows aren't the answer. The future of AI agents lies in smarter memory systems — semantic retrieval, relational linking, and temporal awareness. Here's why agent memory architecture matters more than raw context size.

Read More
Context engineering compression pipeline for AI agents

Context Engineering for AI Agents: How to Stop Your AI from Forgetting

AI agents lose track of goals during long tasks due to context rot. Learn how LangChain's Deep Agents SDK uses a three-layer compression strategy to manage context windows, and what this means for your AI stack.

Read More
Unified LLM gateway routing multiple AI model providers

Why You Should Use a Unified LLM Gateway Instead of Multiple API Keys

Managing multiple AI provider API keys is a growing pain for engineering teams. A unified LLM gateway eliminates key sprawl, simplifies SDK integration, and gives you the freedom to switch between models without changing a single line of code.

Read More

New to PipeLLM? Build faster with the right developer tools. Browse Docs

Start with quickstarts, SDK examples, and production workflow guides.

Frequently Asked Questions

Short answers for teams bringing agents into production.

Answers evolve with the platform.

Ready to ship production agents?

Runtime, routing, and audit in one production layer.

Open Console

Bring agents into production with a governed runtime, controlled routing, and traceable audit.