Imagine: a medical student on a reception — the patient complains of back pain but omits a recent fall. A scripted trainer won't catch the trick, but an AI character 'remembers' the missed question and flags the error at the end of the session. We build exactly such systems — with realistic character psychology and an adaptive scenario for each student. This is not just a dialogue simulation, but a full-fledged situational task where every answer affects the scenario's development. According to IBM Training Report research, companies using AI simulations reduce training time by 40%.
How AI simulations solve the problem of scalable training?
Classic role-playing games require actors and scriptwriters — expensive, and replaying gives the same answer. AI simulations generate a unique dialogue every time: the character reacts to specific words, changes emotions and tactics. At the core is an LLM, framed by a system prompt with a role, goals, and secret information. The code below shows a minimal implementation of such a character.
from openai import AsyncOpenAI from dataclasses import dataclass, field from typing import Optional client = AsyncOpenAI() @dataclass class SimulationCharacter: name: str role: str personality: str objectives: list[str] # Что персонаж хочет добиться knowledge: str # Что персонаж знает emotional_state: str = "neutral" secret_info: str = "" # Информация, которую персонаж скрывает @dataclass class SimulationScenario: title: str learning_objectives: list[str] characters: list[SimulationCharacter] context: str success_criteria: list[str] difficulty: str = "medium" @dataclass class SimulationSession: scenario: SimulationScenario conversation_history: list[dict] = field(default_factory=list) score: float = 0.0 attempts: int = 0 feedback_notes: list[str] = field(default_factory=list) class InteractiveSimulator: def __init__(self): self.client = AsyncOpenAI() async def create_character_response( self, session: SimulationSession, learner_input: str, character: SimulationCharacter ) -> dict: """Генерируем реалистичный ответ персонажа + оценку действий ученика""" system_prompt = f"""Ты — {character.name}, {character.role}. Личность: {character.personality} Твои цели в этой ситуации: {', '.join(character.objectives)} Контекст сценария: {session.scenario.context} Информация, которую ты знаешь: {character.knowledge} {'Скрытая информация (не раскрывать явно): ' + character.secret_info if character.secret_info else ''} Текущее эмоциональное состояние: {character.emotional_state} ВАЖНО: - Отвечай от лица персонажа, реалистично - Реагируй на тактику ученика: хорошие аргументы смягчают позицию, давление усиливает сопротивление - После ответа добавь блок [INSTRUCTOR_EVAL] с оценкой действий ученика (не показывается ему) Верни JSON: {{ character_response: "ответ персонажа", emotional_state_change: "как изменилось настроение", instructor_eval: {{ technique_used: "...", effective: true/false, score_delta: -5..+10, tip: "..." }} }}""" messages = [{"role": "system", "content": system_prompt}] # История диалога for turn in session.conversation_history[-10:]: # последние 10 реплик messages.append({"role": turn["role"], "content": turn["content"]}) messages.append({"role": "user", "content": learner_input}) response = await self.client.chat.completions.create( model="gpt-4o", messages=messages, response_format={"type": "json_object"} ) return json.loads(response.choices[0].message.content) async def evaluate_session(self, session: SimulationSession) -> dict: """Финальная оценка сессии симуляции""" response = await self.client.chat.completions.create( model="gpt-4o", messages=[{ "role": "system", "content": f"""Оцени результаты обучающей симуляции. Цели обучения: {json.dumps(session.scenario.learning_objectives, ensure_ascii=False)} Критерии успеха: {json.dumps(session.scenario.success_criteria, ensure_ascii=False)} Проанализируй диалог и верни JSON: {{ overall_score: 0-100, objectives_achieved: [{{"objective": "...", "achieved": true/false, "evidence": "..."}}], strengths: ["..."], areas_for_improvement: ["..."], specific_feedback: "подробный разбор ключевых моментов", recommended_practice: "что отработать дополнительно" }}""" }, { "role": "user", "content": f"История диалога:\n{json.dumps(session.conversation_history, ensure_ascii=False, indent=2)}" }], response_format={"type": "json_object"} ) return json.loads(response.choices[0].message.content) Why is LLM-based dialogue generation better than scripted trees?
Scripted trees are finite: any unexpected input breaks the scenario, and the student gets 'I didn't understand'. LLM generation covers an infinite input space — the character can adequately respond to 'Are you sure?', 'Show me the research', or even 'Let's discuss a discount'. We use JSON mode (gpt-4o), which guarantees a structured output with action evaluation — no text parsing needed.
| Characteristic | Scripted simulations | AI simulations on LLM |
|---|---|---|
| Number of possible dialogues | 5–20 (limited by branches) | Theoretically infinite |
| Reaction to non-standard input | Error or 'I didn't understand' | Appropriate response within role |
| Emotional adaptation | No | Yes (via prompt and history) |
| Creation complexity | Low (diagrams) | Medium (prompts + testing) |
| Cost per session | Fixed ($200-$500 per role-play) | ~2-10 cents (tokens) |
For a character with long-term memory, we connect RAG with ChromaDB: key facts from the dialogue history are stored in a vector database and retrieved in subsequent encounters. This allows the simulation to remember the student's decisions across multiple sessions — critical for skill assessment and progress tracking.
Ready-made simulations by niche
SIMULATION_TEMPLATES = { "sales_objection_handling": SimulationScenario( title="Handling objections: 'It's expensive'", learning_objectives=["Identify the true objection", "Justify the value", "Propose alternatives"], characters=[SimulationCharacter( name="Mikhail Ivanov", role="Potential client, procurement department head", personality="Pragmatic, values specifics, skeptical of salespeople", objectives=["Get the best price", "Ensure supplier reliability"], knowledge="Knows the market, compared competitors", emotional_state="slightly_negative", secret_info="Has budget but wants to test the seller's flexibility" )], context="Final stage of negotiations for an annual IT solution contract", success_criteria=["Identified budget constraints", "Presented ROI calculation", "Didn't reduce price by more than 10%"] ), "medical_consultation": SimulationScenario( title="Primary consultation for a patient with back pain", learning_objectives=["Take history", "Perform differential diagnosis", "Order examinations"], characters=[SimulationCharacter( name="Patient: Elena Smirnova, 42 years old", role="Patient with lower back pain for 2 weeks", personality="Anxious, has read a lot online about diagnoses", objectives=["Get a specific diagnosis", "Find out if surgery is needed"], knowledge="Pain worsens when bending, numbness in toe", secret_info="Fell at work but is embarrassed to say" )], context="Primary consultation with a neurologist at a clinic", success_criteria=["Asked about injuries", "Ordered MRI", "Explained next steps"] ) } Adaptive difficulty
async def adjust_difficulty( session: SimulationSession, current_score: float ) -> str: """Адаптируем поведение персонажа под уровень ученика""" if current_score > 75: return "more_resistant" # Персонаж жёстче elif current_score < 40: return "more_cooperative" # Персонаж мягче, даёт подсказки else: return "neutral" # Стандартное поведение Adaptive difficulty is implemented by changing character parameters: resistance level, amount of hints, frequency of emotion changes. This allows using one scenario for both beginners and experienced employees — development savings reach 80%.
How is simulation effectiveness evaluated?
We implement metrics at each stage:
| Metric | Description | Target |
|---|---|---|
| completeness | Proportion of scenario objectives achieved | >80% |
| score | LLM evaluation of tactics and results | 0-100 |
| user_satisfaction | Post-session survey | >4.0 out of 5 |
| retention | Repeat session after one month | >60% |
In one project, an A/B test showed a 34% improvement in retention compared to a scripted trainer. Over 10,000 sessions were processed monthly with 99.9% uptime.
Checklist for launching your first simulation
- Define learning goals and target audience
- Write a Character card: role, personality, secret information
- Set up the system prompt with role and evaluation criteria
- Test 50+ dialogues for JSON correctness and latency
- Run an A/B test: control group on script, test group on AI
Our process and what's included
- Analysis: we break down learning goals, target audience, typical mistakes. Create a map of scenarios and characters.
- Design: write Character cards (role, personality, success metrics). Set up system prompts — this determines 80% of simulation quality.
- Implementation: build the backend on Python (FastAPI + asyncio), connect the LLM, version prompts via MLflow. For cheap scenarios we use Llama 3 via vLLM, for complex ones — GPT-4o.
- Testing: run 50+ dialogues per scenario, check JSON correctness, measure latency. Automatically generate robust tests.
- Deployment: containerize and deploy in Kubernetes, connect analytics (which sessions succeeded, where students get stuck).
Note: what's included in the result: documentation on scenarios, API specification, embeddable web component, analytics dashboard, 2 weeks of post-deployment support. Contact us — we'll evaluate your scenario in one day. We implement a turnkey simulation with 1-3 characters in a month.
Timeline: MVP for one scenario with one AI character — 2-3 weeks. Platform with a library of scenarios, analytics, and LMS integration — 2-3 months. Over 5 years of experience in AI solutions, 10+ implemented trainers for medical and sales departments. Contact us to discuss your training scenario — we'll propose the architecture and timeline for free.