Building Agentic AI: Six Agents, One Conversation

Why Single-Prompt AI Fails for Training

The simplest approach to AI-powered training is a single large prompt: stuff the system message with instructions about persona, knowledge, safety rules, and evaluation criteria, then let the model do its best. We tried this early on. It doesn’t work.

A single prompt creates competing priorities that the model can’t reliably balance. Be creative and in-character, but also strictly grounded in source documents. Evaluate the trainee’s performance, but don’t break character to do it. Enforce safety guardrails, but keep the conversation natural. As the prompt grows, reliability degrades. The model starts dropping constraints, usually the safety and grounding ones first, because they’re restrictive while the persona instructions are generative.

We needed an architecture where each concern has a dedicated agent with a focused mandate, and those agents coordinate to produce a single coherent conversation turn.

The Six-Agent Architecture

PersonaTrain’s agentic engine runs six specialized agents that collaborate on every conversation turn. Each agent has a single responsibility, a defined input/output contract, and no knowledge of the other agents’ internal logic.

The Orchestrator is the conductor. It receives the trainee’s message, determines which agents need to activate for this turn, manages the execution order, resolves conflicts between agent outputs, and assembles the final response. It’s the only agent that sees the full picture.

The Knowledge Retrieval Agent handles all interaction with the RAG pipeline. Given the trainee’s input and conversation context, it formulates search queries, retrieves relevant document chunks via semantic search, and scores their relevance. It returns structured context that other agents consume, never raw document text.

The Character Agent generates the in-character response. It receives the persona definition, conversation history, and retrieved knowledge context, then produces a response that sounds like the character while staying grounded in the provided source material. It handles tone, communication style, emotional state, and scenario-appropriate behavior.

The Guardrail Agent is the safety layer. It reviews the Character Agent’s proposed response before it reaches the trainee, checking for hallucinated claims, policy violations, off-topic drift, and content safety issues. It can modify, flag, or block responses. In regulated industry configurations, it enforces domain-specific compliance rules.

The Scenario Progression Agent tracks where the conversation is in the scenario arc. It monitors whether key topics have been covered, whether the trainee has hit milestone moments, and whether the conversation should escalate, de-escalate, or wrap up. It feeds progression signals to the Character Agent to keep the scenario on track.

The Real-Time Evaluation Agent assesses the trainee’s performance on every turn. It scores responses against rubric criteria, product knowledge accuracy, objection handling technique, communication clarity, compliance adherence, and generates feedback that can be surfaced during or after the session.

Parallel Coordination and the Streaming Pipeline

These agents don’t run sequentially, that would be far too slow for a real-time conversation. The Orchestrator dispatches independent agents in parallel. Knowledge Retrieval and Scenario Progression can run simultaneously since neither depends on the other’s output. The Character Agent waits for their results, then generates its response. Guardrail and Evaluation run in parallel on the Character Agent’s output.

The entire pipeline streams. The Character Agent begins producing tokens as soon as it has sufficient context, and those tokens flow to the Guardrail Agent incrementally. If the Guardrail Agent detects an issue mid-stream, it can halt generation before the problematic content reaches the trainee. This streaming architecture keeps response latency under two seconds for text conversations, even with all six agents active.

Why Custom Orchestration Over LangChain

We evaluated LangChain, CrewAI, and other agent frameworks before building our own orchestration layer. The decision came down to three factors: control over the streaming pipeline, the ability to handle partial failures gracefully, and performance.

Off-the-shelf frameworks optimize for flexibility and ease of prototyping. That’s valuable when you’re exploring what’s possible. But when you need deterministic behavior in a production system, where a guardrail failure must halt the response immediately, where evaluation must happen on every turn without adding latency, and where the streaming pipeline must be rock-solid, you need full control over the execution model. Our custom orchestrator gives us that control, and it means we can optimize hot paths, implement circuit breakers per agent, and evolve the coordination logic without fighting a framework’s assumptions.

What This Means for the Training Experience

See these agents in action, read about the AI training revolution or explore our platform features.

The trainee sees none of this complexity. They see a realistic conversation partner who knows the product, stays in character, challenges them appropriately, and never says anything inaccurate or unsafe. That simplicity on the surface is only possible because of the coordinated sophistication underneath. Each agent is excellent at its specific job, and the Orchestrator ensures they work together seamlessly. The result is training conversations that are simultaneously creative, accurate, safe, and pedagogically effective, something no single-prompt approach can reliably deliver.