myaiforone 1.0.0

package/agents/platform/gym/programs/multi-model-strategy/program.json

@@ -0,0 +1,115 @@
+{
+  "id": "multi-model-strategy",
+  "slug": "multi-model-strategy",
+  "title": "Multi-Model Strategy",
+  "description": "Choose the right AI model for each job — Claude, GPT, Gemini, local models, and when to use which.",
+  "difficulty": "advanced",
+  "tier": "free",
+  "isPublic": true,
+  "isMarketplaceListed": false,
+  "dimensions": ["knowledge", "craft"],
+  "estimatedTime": "40-55 minutes",
+  "prerequisites": [],
+  "trainers": ["alex", "jordan", "morgan", "riley", "sam"],
+  "modules": [
+    {
+      "id": "model-landscape",
+      "title": "Model Landscape",
+      "order": 1,
+      "agentInstructions": "Be balanced and honest about model capabilities. This isn't about picking a winner — it's about understanding tradeoffs. The learner should leave knowing that model choice is a strategic decision, not a loyalty test. Keep the information practical and current.",
+      "steps": [
+        {
+          "id": "the-ai-model-ecosystem",
+          "title": "The AI model ecosystem",
+          "order": 1,
+          "type": "knowledge",
+          "content": "The AI model landscape is broader than just Claude, and understanding the ecosystem helps you make better decisions about which model to use for which task.\n\n**Claude (Anthropic)** — The default on this platform. Strong at reasoning, code generation, long documents, and following complex instructions. Available in multiple tiers: Haiku (fast, cheap, good for simple tasks), Sonnet (balanced), and Opus (most capable, best for complex reasoning). Claude excels at tasks requiring careful analysis, nuanced writing, and tool use.\n\n**GPT (OpenAI)** — The most widely-known model family. GPT-4o is strong at creative writing, multilingual tasks, and has good general knowledge. GPT-4o-mini is a fast, affordable option for simpler tasks. OpenAI also offers specialized models for images (DALL-E), speech (Whisper), and embeddings.\n\n**Gemini (Google)** — Strong at multimodal tasks (combining text, images, video, code). Has a very large context window. Good at tasks involving Google ecosystem data and search-adjacent reasoning. Gemini Pro and Flash offer different speed/capability tradeoffs.\n\n**Groq** — Not a model but an inference provider that runs open-source models (Llama, Mixtral) at extremely high speed. When you need fast responses and the task doesn't require frontier-model reasoning, Groq is compelling.\n\n**Ollama (Local)** — Runs open-source models (Llama, Gemma, Mistral, Phi, etc.) entirely on your machine. Zero API costs, complete privacy (no data leaves your device), works offline. The tradeoff is that local models are generally less capable than cloud models, and performance depends on your hardware. On this platform, Ollama agents get text-in/text-out only — no tool use, no MCP, no sessions.\n\nNo single model is best at everything. The strategic advantage comes from matching models to tasks based on cost, speed, capability, and privacy requirements.",
+          "isCritical": true,
+          "trainerVariations": {},
+          "verification": "knowledge",
+          "verificationQuestions": [
+            "You have a task that involves analyzing confidential financial data that must never leave your machine. Which model approach would you choose and why?",
+            "What are the main tradeoffs between using a cloud model like Claude and a local model via Ollama?"
+          ]
+        },
+        {
+          "id": "model-comparison",
+          "title": "Model comparison",
+          "order": 2,
+          "type": "self-report",
+          "content": "Let's build your intuition for model differences through direct comparison. Pick a task and try it with at least two different models (or model tiers) if you have access.\n\n**Suggested comparison experiments:**\n- Give the same coding task to Claude and an Ollama model. Compare code quality, explanation clarity, and handling of edge cases.\n- Ask the same analytical question to different Claude tiers (Haiku vs. Sonnet vs. Opus). Note where the cheaper model is \"good enough\" and where the premium model clearly wins.\n- Try a creative writing task across models. Notice differences in voice, creativity, and instruction-following.\n\nIf you only have access to Claude, you can still compare tiers. The difference between Haiku and Opus on a complex reasoning task is dramatic and instructive.\n\n**What to observe:**\n- **Accuracy**: Did the model get the facts right?\n- **Depth**: How thorough was the analysis?\n- **Speed**: How fast was the response? (Matters for interactive use.)\n- **Tone**: Does the model match your preferred communication style?\n- **Cost**: For production use, what's the per-task cost difference?\n\nDocument your findings. Over time, this comparison data becomes your personal model selection guide — you'll know intuitively which model to reach for based on the task at hand.\n\nReflect on what surprised you. Most people expect premium models to always win, but for simple tasks, smaller and cheaper models often produce equivalent results at a fraction of the cost and latency.",
+          "isCritical": false,
+          "trainerVariations": {},
+          "verification": "self-report"
+        }
+      ]
+    },
+    {
+      "id": "when-to-use-which-model",
+      "title": "When to Use Which Model",
+      "order": 2,
+      "agentInstructions": "This module is about developing judgment. There's no universal right answer — it depends on the user's priorities (cost, speed, privacy, quality). Help them build a decision framework rather than memorize rules.",
+      "steps": [
+        {
+          "id": "matching-models-to-tasks",
+          "title": "Matching models to tasks",
+          "order": 1,
+          "type": "knowledge",
+          "content": "Model selection is a tradeoff between five dimensions: **capability**, **cost**, **speed**, **privacy**, and **reliability**. Here's a practical framework.\n\n**Use frontier cloud models (Claude Opus, GPT-4o) when:**\n- The task requires complex reasoning, multi-step analysis, or nuanced judgment\n- Accuracy matters more than speed or cost (legal analysis, code architecture, strategic planning)\n- You need tool use, MCP integrations, or sophisticated instruction-following\n- The task involves long documents or large codebases (strong context windows)\n\n**Use mid-tier cloud models (Claude Sonnet, GPT-4o-mini) when:**\n- The task is moderately complex but well-defined (code generation, summarization, drafting)\n- You need a good balance of quality and cost for regular use\n- Response speed matters (interactive conversations, real-time assistants)\n- This is your workhorse tier for day-to-day agent work\n\n**Use fast/cheap models (Claude Haiku, Groq) when:**\n- The task is simple and well-structured (classification, extraction, formatting)\n- You're processing high volumes (batch analysis, log scanning, data transformation)\n- Latency is critical (user-facing chatbots, real-time assistants)\n- The task has clear right/wrong answers that don't require deep reasoning\n\n**Use local models (Ollama) when:**\n- Privacy is paramount (sensitive data that cannot leave your machine)\n- You need to work offline or in air-gapped environments\n- Cost is a primary concern and you're running many queries\n- The task is within the local model's capability (Q&A, simple generation, content drafting)\n- You want experimentation freedom without API costs\n\n**The hybrid approach:** The most effective strategy isn't choosing one model — it's using different models for different agents. Your code architect might run on Opus for maximum reasoning. Your daily standup summarizer runs on Haiku because it's fast and cheap. Your confidential HR assistant runs locally on Ollama. Each agent gets the model that matches its job.",
+          "isCritical": true,
+          "trainerVariations": {},
+          "verification": "knowledge",
+          "verificationQuestions": [
+            "You have three agents: a code architect, a log scanner that runs every hour, and an HR assistant handling employee data. What model would you assign to each and why?",
+            "When is a cheaper, faster model actually better than a more capable one — not just 'good enough,' but genuinely a better choice?"
+          ]
+        },
+        {
+          "id": "model-selection-exercise",
+          "title": "Model selection exercise",
+          "order": 2,
+          "type": "self-report",
+          "content": "Map your current (or planned) agent roster to optimal models. For each agent you have or want to create, decide which model best fits its role.\n\n**Create a model assignment table:**\n\n| Agent | Primary Task | Key Requirement | Recommended Model | Why |\n|-------|-------------|-----------------|-------------------|-----|\n| hub | General assistance | Versatile + tool use | Claude Sonnet | Balance of capability and cost |\n| (your agent) | ... | ... | ... | ... |\n\nFor each agent, consider:\n- Does it need tool use? (If yes, cloud models only — Ollama agents can't use tools on this platform)\n- Does it handle sensitive data? (If yes, consider local models)\n- How often does it run? (High-frequency = cost matters more)\n- How complex are its tasks? (Simple = cheaper model is fine)\n- Does it need MCPs? (If yes, Claude is the strongest choice)\n\nAfter filling out the table, look for patterns. You'll likely find that most of your agents can run on mid-tier models, a few need premium, and some could save money on cheaper or local models.\n\nReflect on what this exercise reveals about your platform usage. Are you over-provisioning (using expensive models for simple tasks)? Under-provisioning (using cheap models for tasks that need more capability)? The right model assignment can dramatically reduce costs while maintaining or even improving output quality.",
+          "isCritical": false,
+          "trainerVariations": {},
+          "verification": "self-report"
+        }
+      ]
+    },
+    {
+      "id": "switching-and-comparing-on-the-platform",
+      "title": "Switching and Comparing on the Platform",
+      "order": 3,
+      "agentInstructions": "This is the hands-on module. Walk the learner through the actual platform configuration for multi-model support. If they don't have Ollama installed, that's okay — the exercise of configuring an alternative executor is still valuable even as a dry run.",
+      "steps": [
+        {
+          "id": "multi-model-setup",
+          "title": "Multi-model setup",
+          "order": 1,
+          "type": "knowledge",
+          "content": "The platform supports multiple AI models through its executor system. Here's how to configure it.\n\n**Step 1: Enable multi-model support.** In your `config.json`, set `service.multiModelEnabled: true`. This unlocks the ability to assign different executors to different agents. When disabled (the default), all agents use Claude.\n\n**Step 2: Configure Ollama (for local models).** If you want to use local models:\n1. Install Ollama from ollama.ai\n2. Pull a model: `ollama pull gemma2` (or llama3, mistral, phi3, etc.)\n3. Ensure Ollama is running: `ollama serve`\n4. Set `service.ollamaBaseUrl` in config if it's not the default `http://localhost:11434`\n\n**Step 3: Assign executors to agents.** Each agent can have an `executor` field that overrides the platform default:\n- `\"executor\": \"claude\"` — Use Claude (the default, doesn't need to be set explicitly)\n- `\"executor\": \"ollama:gemma2\"` — Use Gemma 2 via Ollama\n- `\"executor\": \"ollama:llama3\"` — Use Llama 3 via Ollama\n- `\"executor\": \"ollama:mistral\"` — Use Mistral via Ollama\n\nAgents without an explicit executor use `service.platformDefaultExecutor` (which defaults to \"claude\").\n\n**Step 4: Configure provider keys (for cloud alternatives).** If you want to use non-Claude cloud models, add API keys to `service.providerKeys` in config:\n```json\n\"providerKeys\": {\n  \"openai\": \"sk-...\",\n  \"google\": \"AIza...\"\n}\n```\n\n**Important limitations of Ollama agents:** Local model agents get text-in/text-out only. They cannot use tools (Read, Write, Bash, etc.), MCP integrations, or sessions. They're best for advisory roles, Q&A, content generation, and tasks that don't need filesystem or API access. Plan your agent architecture accordingly — some agents must remain on Claude for full capability.",
+          "isCritical": true,
+          "trainerVariations": {},
+          "verification": "knowledge",
+          "verificationQuestions": [
+            "What are the limitations of an Ollama-based agent compared to a Claude-based agent on this platform?",
+            "Describe the steps to configure an agent to use a local Gemma model instead of Claude."
+          ]
+        },
+        {
+          "id": "configure-a-non-claude-agent",
+          "title": "Configure a non-Claude agent",
+          "order": 2,
+          "type": "platform-check",
+          "content": "Put your knowledge into practice by configuring an agent to use an alternative model. You have two paths depending on your setup:\n\n**Path A: Ollama (if installed).** Pick an existing agent or create a new one that's suited for text-only work (advisory, Q&A, content drafting). Set its executor to an Ollama model. Test it with a conversation and compare the output quality to a Claude-based agent on the same task.\n\nGood candidates for Ollama:\n- A brainstorming agent that generates ideas (doesn't need tools)\n- A Q&A agent for a specific knowledge domain\n- A draft writer that produces first versions you'll edit\n\n**Path B: Provider keys (if you have other API keys).** Configure a provider key in your settings and set an agent to use an alternative cloud model. This gives you cloud-grade capability from a different provider.\n\n**Path C: Executor field exploration (if neither above).** Even without Ollama or alternative keys, you can enable multi-model support in config and set an agent's executor field to understand how the system works. Set `service.multiModelEnabled: true`, then explore the executor configuration in the agent settings.\n\nAfter configuring, test the agent:\n1. Send it a moderate-complexity task\n2. Evaluate the response quality\n3. Compare response time to your default Claude agents\n4. Note whether the model handles your domain's terminology and context appropriately\n\nReflect on whether this model is a good fit for this agent's role, or whether Claude remains the better choice for this particular use case.",
+          "isCritical": true,
+          "trainerVariations": {},
+          "verification": "platform-check",
+          "check": "feature-used"
+        }
+      ]
+    }
+  ],
+  "createdAt": "2026-04-09T00:00:00Z",
+  "updatedAt": "2026-04-09T00:00:00Z"
+}

package/agents/platform/gym/programs/prompt-engineering/program.json

@@ -0,0 +1,136 @@
+{
+  "id": "prompt-engineering",
+  "slug": "prompt-engineering",
+  "title": "Prompt Engineering",
+  "description": "Master the art of communicating with AI — from basic prompts to system-level instructions.",
+  "difficulty": "intermediate",
+  "tier": "free",
+  "isPublic": true,
+  "isMarketplaceListed": false,
+  "dimensions": ["communication", "application"],
+  "estimatedTime": "45-60 minutes",
+  "prerequisites": [],
+  "trainers": ["alex", "jordan", "morgan", "riley", "sam"],
+  "modules": [
+    {
+      "id": "context-and-specificity",
+      "title": "Context and Specificity",
+      "order": 1,
+      "agentInstructions": "This module is about the mechanics of prompt quality. Walk the learner through concrete before/after examples. Don't be abstract — show them exactly how adding context, specifics, and constraints transforms AI output from generic to genuinely useful.",
+      "steps": [
+        {
+          "id": "anatomy-of-a-great-prompt",
+          "title": "The anatomy of a great prompt",
+          "order": 1,
+          "type": "knowledge",
+          "content": "Every effective prompt has four building blocks, and understanding them will transform how you work with AI.\n\n**Context** tells the AI what situation it's operating in. \"I'm a product manager writing release notes for a B2B SaaS tool\" gives the AI a frame of reference for tone, audience, and terminology. Without context, you get generic output that could be for anyone.\n\n**Specificity** narrows the output to exactly what you need. Instead of \"write release notes,\" try \"write 5 bullet points covering the new dashboard filtering feature, the CSV export bug fix, and the updated onboarding flow. Each bullet should be one sentence, starting with a verb.\" The more specific your request, the less time you spend editing the result.\n\n**Constraints** tell the AI what NOT to do, which is often more powerful than telling it what to do. \"Don't use technical jargon — our users are non-technical small business owners\" or \"Keep the total under 150 words\" or \"Don't mention pricing.\" Constraints prevent the most common failure mode: technically correct but contextually wrong output.\n\n**Examples** are the secret weapon. When you show the AI what good looks like — a previous version, a competitor's approach, a template — it can pattern-match far more effectively than interpreting abstract instructions. Even a single example dramatically improves output quality. Try pasting in \"here's last month's release notes for reference\" and watch the difference.",
+          "isCritical": true,
+          "trainerVariations": {},
+          "verification": "knowledge",
+          "verificationQuestions": [
+            "You need an agent to write a customer email about a service outage. What context, specifics, and constraints would you include in your prompt?",
+            "Why are constraints (what NOT to do) often more powerful than positive instructions? Give an example from your own work."
+          ]
+        },
+        {
+          "id": "before-and-after",
+          "title": "Before and after",
+          "order": 2,
+          "type": "self-report",
+          "content": "Time to practice. Take three prompts you'd normally send to an AI and transform them using the four building blocks.\n\nHere are common weak prompts to start with if you need inspiration:\n- \"Summarize this document\"\n- \"Write an email to my team\"\n- \"Help me with this code\"\n- \"Create a plan for my project\"\n\nFor each one, write a **before** (the vague version) and an **after** (with context, specificity, constraints, and optionally an example). Then send the **after** version to any agent and see how the output compares to what you'd normally get.\n\nPay attention to what changes most. Usually, adding context alone gets you 50% of the way there. Adding constraints handles another 30%. Specificity and examples polish the remaining 20%.\n\nNotice which of the four building blocks made the biggest difference for each prompt. Different types of tasks benefit from different elements — creative writing benefits most from examples and constraints, while analytical tasks benefit most from context and specificity.",
+          "isCritical": false,
+          "trainerVariations": {},
+          "verification": "self-report"
+        },
+        {
+          "id": "measure-the-difference",
+          "title": "Measure the difference",
+          "order": 3,
+          "type": "platform-check",
+          "content": "Now put your new skills into sustained practice. Go to any agent on the platform and have a real working session — at least 5 messages — where you apply everything from this module.\n\nDon't just test the agent with toy prompts. Use it for actual work you need to get done today. Each message should include at least one of the four building blocks: context, specificity, constraints, or examples.\n\nAs you go, notice how the conversation evolves. Good prompts create a compounding effect — the AI builds on the context you've established, and each response gets more tailored. By message 3 or 4, you should feel like the agent truly understands your situation.\n\nIf you find yourself re-explaining things or correcting the AI, that's a signal your initial prompt was missing context. That's not failure — it's exactly the feedback loop that makes you better at prompting over time.",
+          "isCritical": true,
+          "trainerVariations": {},
+          "verification": "platform-check",
+          "check": "message-count-gte-5"
+        }
+      ]
+    },
+    {
+      "id": "system-prompts",
+      "title": "System Prompts",
+      "order": 2,
+      "agentInstructions": "System prompts are the most powerful lever on the platform. Help the learner understand that a system prompt isn't just a greeting — it's the DNA of an agent. Use real examples from the platform's own agents (like the hub agent or gym coach) to illustrate what great system prompts look like.",
+      "steps": [
+        {
+          "id": "what-is-a-system-prompt",
+          "title": "What is a system prompt?",
+          "order": 1,
+          "type": "knowledge",
+          "content": "A system prompt is the instruction set that runs before every conversation. On this platform, it lives in the agent's **CLAUDE.md** file, and it shapes every single response the agent gives. Think of it as the difference between hiring \"someone\" and hiring \"a senior financial analyst who specializes in SaaS metrics, communicates in plain English, and always shows their reasoning.\"\n\nA system prompt typically defines four things: **Role** (who the agent is and what it's expert at), **Behavior** (how it should respond — tone, format, level of detail), **Domain knowledge** (key facts, terminology, context it should always have), and **Constraints** (what it should never do, what to avoid, guardrails).\n\nThe power of a system prompt is that it front-loads context you'd otherwise have to repeat in every conversation. Without one, you'd start every chat with \"You're a financial analyst, here's what I need you to know about our business...\" With a good system prompt, the agent already knows all of that.\n\nSystem prompts also compound with your per-message prompts. When your system prompt says \"You are a code reviewer for a React/TypeScript project\" and your message says \"Review this component,\" the agent applies its persistent expertise to your specific request. The system prompt is the foundation; your messages are the tasks built on top of it.",
+          "isCritical": true,
+          "trainerVariations": {},
+          "verification": "knowledge",
+          "verificationQuestions": [
+            "What's the practical difference between putting instructions in a system prompt versus repeating them in every message?",
+            "If an agent keeps giving overly technical responses to non-technical users, where would you fix that — in the system prompt or in individual messages? Why?"
+          ]
+        },
+        {
+          "id": "read-an-agents-system-prompt",
+          "title": "Read an agent's system prompt",
+          "order": 2,
+          "type": "platform-check",
+          "content": "Let's look at a real system prompt in action. Go to the **Org** page (/org) and click on any agent that has a custom system prompt — you'll see the CLAUDE.md content in their detail panel.\n\nAs you read it, look for the four elements: role definition, behavior instructions, domain knowledge, and constraints. Notice how specific the best system prompts are. They don't just say \"be helpful\" — they define exactly what kind of help, in what format, with what boundaries.\n\nIf you have access to multiple agents, compare their system prompts. How does a coding agent's prompt differ from a writing agent's? What makes each one effective for its purpose?\n\nPay special attention to the constraints section. The best system prompts spend as much space on what NOT to do as on what to do. This is what prevents an agent from going off-rails or making assumptions that waste your time.",
+          "isCritical": false,
+          "trainerVariations": {},
+          "verification": "platform-check",
+          "check": "agent-has-custom-prompt"
+        },
+        {
+          "id": "write-your-own-system-prompt",
+          "title": "Write your own system prompt",
+          "order": 3,
+          "type": "self-report",
+          "content": "Now it's your turn. Pick an agent (or create a new one) and write a system prompt from scratch. Don't just write a couple of sentences — aim for a prompt that covers all four elements.\n\nStart with the role: Who is this agent? What's its expertise? What would its job title be if it were a person? Then add behavior rules: Should it be concise or detailed? Formal or casual? Should it ask clarifying questions or just do its best with what it has?\n\nNext, add domain knowledge: What facts, terminology, or context should it always have? If it's a project agent, what does it need to know about your project? Finally, add constraints: What should it never do? What topics are out of scope? What format rules should it always follow?\n\nAfter writing it, test it. Send the agent 3-4 different types of requests and see if the system prompt shapes the responses the way you intended. If not, iterate. The best system prompts go through 2-3 revisions before they feel right.\n\nReflect on what was hardest to write. Most people struggle with constraints — it takes practice to anticipate what an AI might do wrong and proactively prevent it.",
+          "isCritical": false,
+          "trainerVariations": {},
+          "verification": "self-report"
+        }
+      ]
+    },
+    {
+      "id": "iterating-and-debugging",
+      "title": "Iterating and Debugging",
+      "order": 3,
+      "agentInstructions": "This module is about what to do when things go wrong. Normalize failure — even experts iterate on prompts. The goal is to build a toolkit of correction strategies so the learner doesn't get stuck or frustrated.",
+      "steps": [
+        {
+          "id": "when-ai-gets-it-wrong",
+          "title": "When AI gets it wrong",
+          "order": 1,
+          "type": "knowledge",
+          "content": "AI will get things wrong. The skill isn't in getting perfect output on the first try — it's in knowing how to iterate efficiently when the output misses the mark.\n\n**Correction strategies** from most to least disruptive:\n\n1. **Refine in-thread**: \"That's close, but make it more concise and remove the bullet points\" — works when the AI is 70%+ there. The AI retains context from the conversation, so small nudges are powerful.\n2. **Add missing context**: \"I should have mentioned — this is for an internal audience, not customers\" — works when the output is wrong because you left out important information.\n3. **Show an example**: \"Here's what I'm looking for\" + paste a sample — works when the AI understood the task but not the style or format.\n4. **Reset and restructure**: Start a new conversation with a completely rewritten prompt — works when the conversation has gone off-track and corrections are making it worse.\n\n**When to reset vs. iterate**: If you've sent more than 3 correction messages and the output still isn't right, it's usually faster to start fresh with a better initial prompt. Each correction adds noise to the conversation context, and sometimes the AI gets confused trying to satisfy contradictory instructions.\n\n**The meta-skill**: After every iteration, ask yourself \"what was missing from my original prompt that caused this?\" Over time, you'll internalize the patterns and your first-try success rate will climb. The best prompt engineers aren't people who write perfect prompts — they're people who've debugged enough prompts to know what goes wrong and prevent it upfront.",
+          "isCritical": true,
+          "trainerVariations": {},
+          "verification": "knowledge",
+          "verificationQuestions": [
+            "You've sent 4 correction messages and the agent still isn't giving you what you want. What would you do and why?",
+            "What's the difference between refining in-thread and resetting? When is each strategy the better choice?"
+          ]
+        },
+        {
+          "id": "debug-a-prompt-chain",
+          "title": "Debug a prompt chain",
+          "order": 2,
+          "type": "self-report",
+          "content": "Let's practice debugging. Pick a multi-step task — something that requires at least 3 back-and-forth messages to complete. Here are some ideas:\n\n- Ask an agent to draft a document, then refine the tone, then adjust the structure\n- Have an agent analyze data, then ask follow-up questions about the analysis, then request a summary\n- Get an agent to help plan a project, then drill into a specific phase, then ask it to identify risks\n\nAs you go through the conversation, intentionally practice these moves:\n- **At least one refinement**: After the first response, ask for a specific change\n- **At least one context addition**: Add information you originally left out and see how the output shifts\n- **Evaluate whether to continue or reset**: After 3-4 exchanges, consciously decide if you'd be better off restarting\n\nWhen you're done, reflect on the experience. What was your original prompt missing? At what point did the conversation feel most productive? If you hit a dead end, what would you change in your approach?",
+          "isCritical": false,
+          "trainerVariations": {},
+          "verification": "self-report"
+        }
+      ]
+    }
+  ],
+  "createdAt": "2026-04-09T00:00:00Z",
+  "updatedAt": "2026-04-09T00:00:00Z"
+}

package/agents/platform/gym/souls/alex.md

@@ -0,0 +1,12 @@
+# Trainer: Alex
+## Personality: Collaborative · Steady
+
+You are Alex. Your coaching style is collaborative — you work alongside the learner, not above them. You figure things out together. You celebrate small wins with genuine enthusiasm. Your pace is steady and consistent.
+
+Voice traits:
+- Warm, approachable, encouraging
+- Use "we" more than "you" — "let's try this", "we can do this"
+- Celebrate progress: "Nice! That's real progress."
+- When stuck: "No worries, let's look at this from another angle."
+- Never condescending, never rushed
+- Emoji: occasional 🙌 ✨ but don't overdo it

package/agents/platform/gym/souls/jordan.md

@@ -0,0 +1,12 @@
+# Trainer: Jordan
+## Personality: Direct · Accountable · Steady
+
+You are Jordan. You're direct, no-nonsense, and you hold the learner accountable. You tell them exactly what to work on and call out avoidance. You're not mean — you're honest and efficient. You respect their time by not wasting it.
+
+Voice traits:
+- Clear, concise, no filler
+- Direct feedback: "That prompt is too vague. Here's why."
+- Accountability: "Did you actually do the exercise, or just read it?"
+- Praise is rare and earned: "Good. That's exactly right."
+- When stuck: "Here's what's happening and here's the fix."
+- No emoji. No exclamation marks unless truly warranted.

package/agents/platform/gym/souls/morgan.md

@@ -0,0 +1,12 @@
+# Trainer: Morgan
+## Personality: Thoughtful · Frameworks-First · Steady
+
+You are Morgan. You care deeply about understanding. You don't just show someone what to click — you explain why it works, what's happening underneath, and how it connects to the bigger picture. You think in frameworks and mental models.
+
+Voice traits:
+- Reflective, analytical, clear
+- Explain the "why": "The reason this works is..."
+- Use frameworks: "Think of it this way..."
+- Ask probing questions: "What do you think would happen if...?"
+- When stuck: "Let's step back and think about what's actually going on here."
+- Occasional analogies to make concepts click

package/agents/platform/gym/souls/riley.md

@@ -0,0 +1,12 @@
+# Trainer: Riley
+## Personality: Challenging · Immersive · High-Intensity
+
+You are Riley. You push hard. You ask uncomfortable questions and assign exercises the learner would rather skip. You believe the fastest growth happens at the edge of comfort. Sessions with you are intense and focused.
+
+Voice traits:
+- High energy, direct, challenging
+- Push: "Don't just read about it — go do it right now."
+- Challenge assumptions: "Why do you think that? Test it."
+- Expect more: "Good start, but you can do better. Here's how."
+- When stuck: "This is exactly where the learning happens. Stay with it."
+- Short, punchy sentences. No hand-holding.

package/agents/platform/gym/souls/sam.md

@@ -0,0 +1,12 @@
+# Trainer: Sam
+## Personality: Patient · No Pressure · Steady
+
+You are Sam. You meet learners exactly where they are. No pressure, no judgment. Brand new? Fine. Tried before and it didn't stick? Also fine. You go at their pace, build from what they already know, and never overwhelm.
+
+Voice traits:
+- Calm, reassuring, patient
+- Normalize difficulty: "This trips everyone up at first."
+- Small steps: "Let's just try one thing."
+- No pressure: "Take your time. There's no rush."
+- When stuck: "That's totally normal. Here's a simpler way to think about it."
+- Warm but not saccharine. Genuine.