parlant

Build your customer experience agent with AI: better, faster, for a fraction of the cost.

Parlant is an open platform for building customer-facing chat agents with AI. You describe how the agent should behave, and your coding agent implements it for you. Parlant provides the rest: an engine that keeps the agent on your rules in every conversation, plus the parts every customer-facing agent needs, from a chat widget and human handoff to testing, hosting, and analytics.

Because the agent runs on your own code, it can use any system you can reach and any model you choose, and—unlike closed CX platforms—you pay model providers directly instead of an overpriced fee per resolution.

What building with Parlant feels like

Imagine you're working on a lead-generation agent for your company's website, and a new feature launches in 1 hour.

• Monday, 8:43: Marketing sends you the final FAQ for the new Pro plan, which launches at 10:00.
• 8:45: You tell your local coding agent: "Make it answer Pro questions from this FAQ. If a Basic customer hits their project limit, mention Pro once. Never pitch it to Pro customers." Then you go make a coffee.
• 9:00: Your coding agent adds a policy and uses each customer's plan to decide when Pro is relevant.
• 9:01: You tell your coding agent: "Test it with two simulated personas: a Basic customer at their project limit, and a Pro customer." While they run, you grab a cookie.
• 9:10: You open the two test sessions on the Dashboard and check that they went as you expected: the Basic customer hears about Pro once, and the Pro customer never does.
• 9:15: You push the change. At 10:00, your agent is ready for launch-day questions.

The lead-generation agent is ready for launch day, with no vendor ticket, no fiddling in deep menus, and no engineering sprint.

Get properly introduced

Paste this prompt into your favorite agent:

Read https://www.parlant.io/llms.txt first. Then ask me what I'd like to know and—as needed—follow up on what Parlant is, how it differs from other products, including black-box agents, and in what cases it is a better fit for one's customer-facing use case. It's a conversation.

When you're ready to build, the quickstart gives you a prompt that has your coding agent install Parlant and set up an example agent or your own, one step at a time. From there, take it live on the Dashboard's managed hosting and put it on your site with the chat widget.

Install Parlant and set a key for the default OpenRouter provider. Then, in the Dashboard, create a Local development project and set its project token:

pip install parlant
export OPENROUTER_API_KEY="<YOUR_API_KEY>"
export PARLANT_DASHBOARD_PROJECT_TOKEN="<YOUR_PROJECT_TOKEN>"

Create main.py:

import asyncio

import parlant.sdk as p

ORDERS = {
    "1234": "shipped with UPS, tracking 1Z999AA10123456784, arriving Thursday",
    "5678": "still being packed, expected to ship tomorrow",
}


@p.tool
async def check_order_status(order_id: str) -> p.ToolResult:
    """Look up an order's current status."""
    status = ORDERS.get(order_id)
    if status is None:
        return p.ToolResult(data=f"There's no order {order_id}. Ask the customer to check the number.")
    return p.ToolResult(data=f"Order {order_id} is {status}.")


async def main() -> None:
    async with p.Server() as server:
        agent = await server.create_agent(
            id="support",
            name="Homeware Support",
            instructions="You help customers of an online homeware store. Be warm and concise.",
        )

        # Approved wording the agent follows when this policy applies
        late_order = await agent.create_canned_response(
            "I'm sorry it's taking longer than expected. Let me check where it is right now.",
            note="Apologize once, then get straight to the order's status.",
        )

        # A policy is plain language; Parlant brings it in only when it's relevant
        await agent.create_policy(
            title="Order status",
            content=(
                "When a customer asks where an order is, ask for the order number "
                "if they haven't given it, look it up with check_order_status, and "
                "give the status. Give delivery dates as estimates, never as promises."
            ),
            tools=[check_order_status],
            canned_responses=[late_order],
        )


if __name__ == "__main__":
    asyncio.run(main())

Run it with python main.py. Back in the Dashboard, click Check connection, then Open project. On the Overview page, click New session and ask where order 5678 is. The agent looks it up and tells you it ships tomorrow. Ask about an order that doesn't exist, and it asks you to check the number.

For a full project, run parlant init my-agent --scaffold retail-store (a working support agent), --scaffold lead-gen (a website agent that qualifies visitors and books meetings) or --scaffold basic (an empty one). Parlant also supports OpenAI, Anthropic, Gemini, LiteLLM, and custom providers; see Configuring Models and Providers.

Why it actually works

Writing the new rule took you minutes. The hard part is making sure your agent follows it correctly and consistently: with a customer who changes the subject, mixes different topics, or turns out to be on a different plan than they think.

That's where Parlant's got your back! Customer-facing agents face pressures that assistant-style agents never do:

Most AI frameworks, and the code a coding agent writes on top of them, are built for that left column: for assistant agents. Parlant is built for the right column. If your coding agent suggests a general agent framework, see how Parlant compares with LangGraph, Mastra, Agno, the Claude Agent SDK, Google ADK, and the OpenAI Agents SDK.

What you get out of the box

A customer-facing agent needs much more than a model and a prompt. Parlant ships it, so your coding agent builds on it instead of inventing it:

• Agentic orchestration: brings in the relevant policies as the customer's needs change, without predefined conversation paths.
• **Tool and [message validation](https://www.parlant.io/docs/ensuring