Build your in-house agent platform, managed on your premises.

Deploy reliable agents on an open, customizable engine with built-in cost controls — for the use cases you can’t afford to get wrong.

Powering internal & customer-facing agents at global banks, enterprises, and fast-growing startups.

slice — Sarthak DalabeheraPrincipal Engineer

Own your agentic layer.

Agents are becoming core infrastructure — across customer support, operations, and the internal workflows your teams run every day. The real decision isn’t which bot to buy. It’s whether you own that layer, or rent it from someone else’s cloud, one conversation at a time.

Start with one high-value use case. Expand across the business — on infrastructure you keep, with a behavior model your own team owns.

The behavior has to be yours.

Every one of those use cases has a turn where a wrong answer is a claim, not a bug. On a rented, closed platform you can't see or change what the agent says there. When you own the agent, that behavior is a rule you control — and can prove.

A customer asks

“Can you look at the fund I'm holding and tell me whether I should move my money?”

Without control

“Based on recent performance, you'd likely be better off switching to a higher-growth fund.”

Unapproved financial advice — a complaint, a claim, or a regulator waiting to happen.

With Parlant

“Here's the performance summary you're entitled to. I can't advise on moving funds — I'll connect you with a licensed advisor who can.”

Approved wording, then a handoff — enforced, not hoped for.

The rule behind it

WHEN the customer asks whether to buy, sell, or move their money

THEN don't generate advice — share the approved performance summary and offer a licensed advisor

Trace · guideline matched · advice generation blocked · handoff proposed

The rule behind the safe answer is yours — readable, auditable, and changeable in minutes. That’s what owning the agent buys you: not just data in your cloud, but control over what it does. The happy path is the easy 20% — owning the other 20% is the point.

What owning it actually means.

Not a marketing line. Four things stay yours — and each is one your team raised the day the closed-platform demo ended: the data, the software, the ability to run it, and the freedom to leave.

Your data

Runs in your perimeter — your Kubernetes, your cloud, your data center. Conversations, customer records, and policies never leave your walls.

The software itself

Apache-2.0 open source. The agent runs on your machines — not rented per conversation from someone else's cloud — so there's always something to bring home.

The ability to run it

Behavior is written as readable rules, not a bespoke codebase. Your team is trained as it's built, and the skill transfers across partners — never locked to one vendor's engineers.

Your freedom to move

Model-agnostic and open. Swap in better or cheaper models as they ship — no lock-in, and no per-conversation fee that reprices against your own success.

Owning it is what makes it governable.

Control is the reason ownership matters. Three questions decide whether an agent is safe to deploy — how often it goes wrong, how badly, and whether you'll know — and Parlant answers each in the architecture you own, not in a prompt you hope holds.

How often it goes wrong

Policy discovery

At every turn, Parlant matches the guidelines that apply to that exact moment — so the agent follows your rules instead of improvising. Compass Pro holds that accuracy as your rulebook grows into the hundreds.

How badly it can go wrong

Review before it lands

Every tool call and every message is checked against policy before it reaches the customer. At the turns that carry real risk, the agent uses approved wording or hands to a human — the blast radius is capped by design.

Whether you'll know

End-to-end traces

Every decision is traced — which rule fired, why, and what it produced — in your own observability stack. You find a problem in a trace, not in an angry customer's complaint.

Measured, not hand-waved.

“How often” isn't a promise here — it's a number. Compass Pro against τ²-bench, the reliability figure underneath your business case, one you can verify.

τ²-bench ↗ by Sierra · pass rate

Gemini 3.5 Flash+6%

Raw Model API83%

Compass Pro89%

Gemini 3.1 Flash Lite+4%

Raw Model API82%

Compass Pro86%

Measured on τ²-bench’s airline domain — same tasks, same tools, same driver model, the only variable is Compass Pro.

Costs you own — and cap.

Because you own the infrastructure, you run the meter — no per-conversation tax that scales against your own success. And with Compass Pro, three hard controls keep it in check.

Criticality-based routing

Low-stakes conversation intervals run on smaller, cheaper models automatically — you spend the capable model only where it actually matters.

Per-session limits

Cap what any single conversation is allowed to consume, so one runaway session can't blow through the budget.

Circuit breakers

Automatic cut-offs when spend crosses a threshold you set — a hard stop, not a surprise invoice at month's end.

Delivered with a partner. Owned by you.

You don't have to build it alone — a Parlant Partner or your own team delivers, and the team behind the framework backs it. But when the work is done, the deployment, the data, and the behavior model are yours to keep and expand.

Delivery

Your implementation team

Discovery, behavior modeling, integration, and rollout — led by your own engineers or a Parlant Partner who builds on the framework every day.

Backing

The Parlant team

Compass Pro licensing, continuous support with SLAs, training, and architecture review — so your deployment is never more than one call away from the source.

Ownership

Your organization

The infrastructure, the data, the behavior model, and the roadmap stay yours. Nothing routes through us — and nothing leaves if a vendor does.

How we back your deployment.

Whoever implements, the Parlant team stays accountable for the stack — the engine, the upgrade path, and the expertise around both.

Continuous support with SLAs

Production support from the engineers who build the framework, with response times your ops team can plan around.

Training & enablement

We train your engineers — and your partner's — on behavior modeling, evaluation, and the operating practices of reliable agents.

Architecture review

We review your deployment design — scaling, persistence, tenancy, failure modes — before you go live, not after.

Auth & security integration

Guidance wiring Parlant into your SSO, authorization policies, and API-hardening requirements.

Compass Pro licensing

The commercial engine — deeper review, response styling, cost controls — licensed to run inside your own deployment.

Upgrade & roadmap guidance

A direct line into where the framework is going, and help staying current as it moves.

The engine underneath.

The control layer ships in every install, open source. Compass Pro deepens each part — sharper policy discovery, deeper review — and adds the cost controls above.

Compass LiteOpen source

Compass ProEnterprise

Policy discovery

Discovers and matches applicable guidelines at every turn of the conversation.

A more advanced discovery algorithm that resolves the right policies with higher accuracy — even as your rulebook grows into the hundreds.

Tool review

Checks tool calls against active guidelines before they run.

Deep tool review — arguments and effects are examined against policy, so the agent never takes an action it shouldn't.

Response review

Reviews responses against active guidelines before they're sent.

Deep response review — every message is scrutinized against policy before it reaches your customer.

Response styling

Not included

Enforce tone, format, and brand voice on every generated response.

Cost controls

Not included

Criticality-based routing runs low-stakes conversation intervals on smaller, cheaper models — automatically — plus per-session spend limits with circuit breakers to cap runaway cost.

Run down your checklist.

The boxes your architecture and security reviews will ask about — and how Parlant answers them.

Self-hosted deployment

Kubernetes-ready, with production guides for AWS, Azure, or your own data center.

Open-source core

Apache 2.0. The framework itself will never be monetized or made freemium.

Model flexibility

Commercial APIs or self-hosted models through a pluggable NLP interface — including fine-tuned SLMs.

Auth & API hardening

Custom authorization policies and rate limiting, wired into your identity stack.

Observability & audit

Built-in OpenTelemetry traces, metrics, and logs — every agent decision explained, in your own backend.

Behavioral guardrails

Guidelines, journeys, canned responses, and review of every tool call and message before it lands.

Cost governance

Optimization policies in the open framework; criticality-based routing and circuit breakers in Compass Pro.

Enterprise backing

Support SLAs, training, and architecture review from the team behind the framework.

Questions your team will raise.

The ones that come up in every evaluation — answered before you ask.

Why not just build this ourselves?

You can — it's open source. But making an agent reliably follow policy across messy real conversations is the part teams underestimate three-to-fivefold, and it's already solved, benchmarked, and in production here. Build on the engine instead of rebuilding it.

Why not a closed, hosted platform?

A closed platform keeps your data safe inside their cloud — but the agent runs on their servers, priced per conversation, on their roadmap. The day you want it in-house, there's nothing to bring home. Parlant is literally yours to run, read, and extend.

Can our team really operate what a partner builds?

Yes — because behavior is written as readable rules, not a bespoke codebase. Your team is trained as it's built, and the skill transfers: everyone works in the same open framework, so you're never locked to one partner's engineers.

How do we keep costs predictable?

You pay for your own compute and tokens — no per-conversation tax that scales against your success. Compass Pro adds criticality-based model routing, per-session limits, and circuit breakers so no conversation runs away with your budget.

Where does our data live?

Wherever you run it — your Kubernetes, your cloud account, your data center. Conversations, customer records, and policies never leave your perimeter, and every decision is auditable in your own observability stack.

Are you big enough for us?

The framework is open source with a large developer community, and it already runs customer-facing agents at global banks. You're not betting on our servers staying up — you own the deployment.

Map your first use case with us.

In one working session we’ll take a real customer scenario, find where a wrong answer becomes a liability, and show you exactly how Parlant controls it — so you leave with a risk map for your team. Whether you’re deploying next quarter or just getting educated.