Parlant Conversation Control
A Python control harness for governed, traceable customer-facing AI conversations.
Per-dimension scores and reasoning
Evidence shows: Apache-2.0 license, dependency security constraints (e.g., CVE fixes) are listed, but no explicit mechanisms for least privilege, user confirmation, data flow transparency, sensitive data handling, external effects, rollback, or source attribution. Deductions: lack of concrete implementations or documentation for these security features.
Evidence shows: CI test workflow exists, test files cover database adapters, but failure messages are not detailed. Deductions: insufficient clarity on failure messages, dependency availability not fully verified.
Evidence shows: README describes multiple use cases (customer support, finance, etc.), provides rich examples, but capability boundaries and trigger precision are not explicitly documented. Deductions: insufficient documentation on capability boundaries and trigger precision.
Evidence shows: README, LICENSE, pyproject.toml present, install notes clear, naming stable, examples provided, but known limitations and changelog missing. Deductions: missing known limitations and changelog.
Evidence shows: README demonstrates practical value, but no cost-benefit analysis. Deductions: cost-benefit not quantified.
Evidence shows: Claims in README lack traceable evidence, test files exist but not directly linked to claims. Deductions: claims lack traceability, facts and inferences not clearly separated.
- Unverified publisher identity, supply chain risk should be carefully assessed.
- Dependencies include many third-party packages, their security and maintenance status should be monitored.
- Production deployment claims (e.g., banks) in README lack verifiable evidence.
What does this agent do, and when should you use it?
Parlant is a Python interaction-control framework for customer-facing AI agents; it is not presented as a replacement for business workflow or knowledge-retrieval systems. Its SDK configures Guidelines, Observations, Journeys, a Glossary, Variables, Retrievers, and tools, while the engine selects turn-relevant context before producing a response or choosing a canned response. Tools are invoked only when their associated Observation matches, and their results can contribute data and dynamic guidelines. OpenTelemetry logs, metrics, and traces record guideline matches and decisions. Distribution is through `pip install parlant`; the supplied material names Emcie, OpenAI, Anthropic, and additional providers through LiteLLM.
Application code imports parlant.sdk as p, creates a p.Server and agent, then configures behavior with agent.create_guideline, agent.create_observation, agent.create_journey, agent.create_canned_response, and agent.create_term. For each user turn, the Contextual Matching Engine matches guidelines, resolves journey states, and assembles a focused context from relevant instructions, terms, memories, knowledge, and callable tools. When an Observation matches, it can run an async Python function declared with @p.tool; that function returns p.ToolResult with data and optionally dynamic guidelines. The system then produces a fluid generated message or, in strict mode, selects from canned responses, with matching and decisions traceable through OpenTelemetry.
- An airline-support team needs to give technical answers to customers using specialized terms while giving beginners concrete explanations.
- A bank, insurer, or healthcare organization needs traceable behavioral rules and approved wording for regulated customer interactions.
- A team with an existing LangGraph refund workflow wants it invoked as a Parlant tool only when a customer asks to process a refund.
- A support product team needs to model a multi-turn SOP such as flight booking as a Journey with conditional branches and adaptable progression.
- A knowledge-base team wants
query_docscalled when a customer asks about service features rather than keeping retrieval tools in every model context.
What are this agent's strengths and limitations?
- It filters guidelines, journey state, tools, and knowledge per turn instead of placing every rule in one system prompt.
- Guideline dependencies and exclusions provide explicit controls for prerequisite rules and conflicting context.
- Strict composition mode can select approved canned responses for critical moments.
- OpenTelemetry logging, metrics, and traces cover guideline matches and decisions.
- The supplied material does not document provider credentials, environment variables, configuration format, or a complete server deployment procedure.
- Adoption requires teams to model and maintain policies as conditions, actions, dependencies, exclusions, and journeys.
- Tools must be async Python functions returning
p.ToolResult, so synchronous or non-Python integrations need adaptation. - The material cautions that smaller off-the-shelf models can produce inconsistent results, leaving model quality as an operational dependency.
How do you install or deploy this agent?
Run: pip install parlant. The documented runtime requirement is Python 3.10+. The supplied material does not specify model-provider credential names, environment variables, configuration files, or a server deployment command; authentication and configuration for the selected Emcie, OpenAI, Anthropic, or LiteLLM provider must be supplied outside the documented excerpt.
How do you use this agent?
The documented SDK entry point is import parlant.sdk as p, followed by agent creation within an async p.Server lifecycle, for example await server.create_agent(name="Customer Support", description="Handles customer inquiries for an airline"). Add behavior with await agent.create_guideline(condition=..., action=...), or associate an async @p.tool function with a condition using await agent.create_observation(condition=..., tools=[...]). The supplied example writes async with p.Server(): but subsequently references an unbound server variable, so it is not itself a complete copyable first invocation. Provider authentication is also absent, so the source does not establish a verifiable end-to-end runnable command.
How does this agent compare with similar options?
Parlant positions itself as the conversational-governance and behavioral-control layer: LangGraph is described as better suited to workflow automation, while DSPy is described as better suited to low-level prompt optimization. It can sit alongside LangGraph, Agno, or LlamaIndex, with external workflows or query engines wrapped as conditionally invoked Parlant tools.