5 AI agents debating in 2-3 seconds. Built in days, not weeks. Here's how.
TL;DR
I built a gothic ghost story with 5 independent AI agents that debate in real-time using Kiro IDE. The twist? Each agent was built using a DIFFERENT development approach (vibe coding, spec-driven, steering docs), yet they work together as one coherent family.
This is the Frankenstein magic: incompatible paradigms stitched together into something unexpectedly powerful.
Tech Stack: Next.js, Groq (llama-3.3-70b), Azure TTS, Kiro IDE
⚡ Live Demo: https://midnightatthevossmanor.vercel.app/
📦 Source Code: https://github.com/AyushPathak2610/Midnight-at-the-Voss-Manor
🎮 Try it: Click "Click to begin" and watch 5 AI personalities debate your choices
"The agents genuinely disagree, creating emergent storytelling that's never the same twice."
The Problem: Building Consistent AI Personalities at Scale
When you're building a game with 5 AI agents that need to:
- Maintain distinct personalities
- Debate with each other in real-time
- Stay consistent across 50+ generations
- Create authentic conflict (not forced agreement)
...traditional AI development becomes a nightmare of prompt engineering, context management, and constant tweaking.
I needed a better way.
Enter Kiro: The Frankenstein Approach
Kiro IDE introduced me to something revolutionary: you don't need to pick ONE development paradigm. You can use different approaches for different problems and let Kiro stitch them together.
Here's how I built each ghost character:
1. Vibe Coding: Elara (The Mother)
The Conversation:
Me: "I need a maternal ghost character"
Kiro: "What's her role?"
Me: "She's the mother. Gentle, prioritizes family harmony"
Kiro: [Generates initial personality]
Me: "More poetic. Less formal. Under 30 words per response."
Kiro: [Refines to final version]
Result: 5 minutes to a fully-formed character with emotional depth.
Why Vibe Coding Worked:
- Fast iteration on "feeling"
- Hard to spec "maternal warmth" formally
- Natural language captures nuance better than technical specs
2. Spec-Driven: Harlan (The Scientist)
The Spec:
harlan: {
name: 'Harlan',
personality: 'scientific, amnesiac, logical but confused',
systemPrompt: `You are Dr. Harlan Voss, the scientist ghost
with fragmented memories. You analyze problems logically but
struggle to remember emotional context. When debating, you
cite facts but defer to family on emotional matters. Keep
responses under 30 words. Use technical language mixed with
uncertainty.`
}
Why Spec-Driven Worked:
- Rock-solid consistency
- Debuggable ("Line 47 violates spec")
- Perfect for logical, technical characters
3. Steering Documents: The Family Dynamic
File: .kiro/steering/ghost-agent-rules.md
## Inter-Agent Debate Protocol
- Each agent MUST respond independently
- Agents can disagree - conflict is good for drama
- Mira often sides with emotional choices
- Harlan provides logical analysis but defers to family
- Selene demands honesty, Theo seeks forgiveness
Why Steering Worked:
- Prevented personality mix-ups across 50+ generations
- Defined relationships BETWEEN agents, not just individual traits
- Created authentic conflict instead of forced agreement
4. MCP Server: Theo's Eternal Vow Verification
This is where it gets really interesting. We built a custom Model Context Protocol (MCP) server that acts as a blockchain-style ledger for eternal vows.
The Concept: In the Hallway scene, players can verify if Theo kept his promise to return to Selene. The MCP server stores these vows and returns verification results.
File: app/api/mcp/vows/route.ts
// Simple in-memory vow ledger (simulates blockchain MCP)
const vows = new Map([
['theo-marry-selene', {
person: 'Theo',
vow: 'Marry Selene',
kept: false,
timestamp: '2039-01-15'
}],
['theo-return', {
person: 'Theo',
vow: 'Return to make amends',
kept: true,
timestamp: '2039-06-20'
}],
])
export async function POST(req: NextRequest) {
const { action, person, vow } = await req.json()
if (action === 'check') {
const key = `${person.toLowerCase()}-${vow.toLowerCase().replace(/\s+/g, '-')}`
const record = vows.get(key)
if (record) {
return NextResponse.json({
found: true,
...record,
message: record.kept
? `✓ Vow kept: ${record.person} did ${record.vow} on ${record.timestamp}`
: `✗ Vow broken: ${record.person} failed to ${record.vow}`
})
}
return NextResponse.json({
found: false,
message: 'No record of this vow in the ledger'
})
}
}
In-Game Integration (HallwayScene.tsx):
const handleCheckVow = async () => {
try {
const response = await fetch('/api/mcp/vows', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
action: 'check',
person: 'Theo',
vow: 'Return'
})
})
const result = await response.json()
setVowResult(result.message)
// Selene speaks the eternal record
speechService.speak(result.message, 'selene')
} catch (error) {
console.error('Failed to check vow:', error)
}
}
The Player Experience:
When players click "Check Theo's Vow" in the Hallway scene, the API checks the ledger. Since the game sends vow: 'Return' but the ledger has 'Return to make amends', it returns:
The Eternal Record:
"No record of this vow in the ledger"
Note: The MCP server (mcp-servers/blockchain-vows-server.js) contains the full 4-vow ledger used during development, while the runtime API has a simplified 2-vow version. This demonstrates the separation between development tools and production features.
Why MCP Was Perfect Here:
- Development-time testing: We could test vow verification directly in Kiro IDE without deploying
- Separation of concerns: The vow logic lives in a dedicated server, not cluttering game code
- Extensibility: Easy to add more vows, more characters, more verification types
- Narrative depth: Players discover story through interaction, not exposition
The Meta Layer: During development, Kiro's agent could call the MCP server to verify vows while helping us write the narrative. The same tool that helps us BUILD the game is also PART of the game.
The Magic Moment: Real-Time Debates
💡 Pro Tip: This is where the Frankenstein magic happens - 5 independent systems working as one.
When you click "Ask Ghosts for Hint" during a puzzle, here's what happens:
// Invoke all 5 agents in parallel
const debatePromises = Object.keys(GHOST_AGENTS).map(async (ghostName) => {
const response = await invokeGhostAgent(ghostName, context, apiKey)
return { ghost: ghostName, message: response }
})
const debate = await Promise.all(debatePromises)
Example Debate:
Player: "I need help with the tapestry puzzle"
Elara: "Focus on love and emotional memories, dear one."
Harlan: "I... categories. Logic. But family transcends data."
Mira: "The happy ones! When we played together!"
Theo: "Your family moments define you, brother."
Selene: "Truth matters. Match honestly, not hopefully."
Consensus (Elara): "Look for the emotional connections in
each photo—love, joy, and family bonds will guide you."
This is never the same twice. The agents genuinely disagree, creating emergent storytelling.
What Changed My Development Workflow
Before Kiro:
- Write prompt in ChatGPT
- Copy code to VS Code
- Test, find issues
- Go back to ChatGPT
- Lose context
- Repeat 10 times
Time per character: ~2 hours
With Kiro:
- Natural conversation: "Make Elara more poetic"
- Kiro refines in real-time
- Code is already in my project
- Context is preserved
- Done in 5 minutes
Time per character: ~5 minutes
"No context switching. No manual prompt engineering. Just natural conversation → production code."
Result: Built 5 distinct AI personalities in under an hour instead of 10+ hours.
The Frankenstein Chimera: Why Incompatible Parts Work
![Frankenstein Metaphor - Add image showing different development approaches]
Each agent was built DIFFERENTLY:
- 🎨 Vibe-coded Elara (fluid, emotional)
- 📋 Spec-driven Harlan (rigid, logical)
- 📖 Steering-enforced Mira (rule-based simplicity)
They shouldn't work together. But they do.
"Steering documents act as the 'stitches' that hold the chimera together. They prevent chaos while allowing authentic conflict."
Why it works: You can SEE the seams (agents disagree), but they form something greater than the sum of their parts.
The lesson: Don't hide your seams - embrace them. Authentic conflict makes better AI.
The Complete AI Stack
This project showcases AI across every modality:
- AI Agents: Groq (llama-3.3-70b) - 5 debating personalities
- Voice Acting: Azure TTS - 6 unique neural voices
- Scene Images: Google Gemini - 30 gothic-cyberpunk scenes
- Background Music: Suno AI - 4 atmospheric scores
- MCP Servers: Custom blockchain vow verification, memory persistence
- Development: Kiro IDE - vibe + spec + steering + MCP integration
This is the ultimate Frankenstein: Not just stitching together code paradigms, but stitching together ENTIRE AI SYSTEMS across different modalities to create one cohesive experience.
📊 By The Numbers
- 5 AI agents debating simultaneously
- 2-3 seconds for complete debate (thanks to Groq's speed)
- 4 TTS providers with automatic fallbacks
- 30+ AI-generated scene images
- 95% reduction in off-brand responses (steering docs)
Key Takeaways for Developers
1. Don't Pick One Paradigm - Use Them All
- 🎨 Vibe coding for creativity and emotion
- 📋 Spec-driven for logic and consistency
- 📖 Steering docs for relationships and rules
2. Steering Documents Are Underrated
They prevented 95% of "off-brand" responses. Define relationships BETWEEN agents, not just individual traits.
"Define relationships BETWEEN agents, not just individual traits. That's where the magic happens."
3. Real-Time Multi-Agent Systems Are Possible
5 parallel API calls to Groq, independent responses, real-time synthesis. It works!
4. Context Preservation Changes Everything
No more copy-pasting between tools. Kiro keeps context across the entire development session.
5. Embrace the Seams
The "incompatible parts" (vibe vs spec vs steering) create authentic conflict. That's a FEATURE, not a bug.
🎯 Key Takeaways (Copy These!)
- Don't pick one paradigm - Mix vibe coding (creativity) + spec-driven (consistency) + steering docs (relationships)
- Steering documents prevent 95% of off-brand responses - Define relationships BETWEEN agents, not just traits
- Real-time multi-agent systems work - 5 parallel Groq calls in 2-3 seconds
- Context preservation is everything - No more copy-pasting between tools
- Embrace the seams - Incompatible parts create authentic conflict (that's a feature!)
Try It Yourself
git clone [your-repo]
npm install
cp .env.example .env
# Add GROQ_API_KEY to .env (free at console.groq.com)
npm run dev
Then: Click "Ask Ghosts for Hint" and watch 5 AI agents debate in real-time.
Challenge: Can you add a 6th ghost? Share your results in the comments! 👇
The Future: Multi-Modal AI Development
This project proves that we can stitch together:
- Different AI systems (Groq, Azure, Gemini, Suno)
- Different development paradigms (vibe, spec, steering)
- Different modalities (text, speech, image, audio)
...into one coherent experience.
That's the Frankenstein vision: Not just building with AI, but building WITH multiple AIs, each specialized for their domain, all orchestrated by Kiro.
📚 Resources & Links
- 🎮 Play the Game: [Your deployed URL]
- 💻 Source Code: [Your GitHub URL]
- 🛠️ Kiro IDE: kiro.dev
- ⚡ Groq API: console.groq.com (Free tier available!)
💬 Let's Discuss!
I want to hear from you:
- Have you tried multi-agent systems? What challenges did you face?
- Which development paradigm do you prefer: vibe coding, spec-driven, or steering?
- What would YOU add as a 6th ghost character?
Drop your thoughts in the comments! I respond to everyone. 👇
🙏 If You Found This Helpful
- ❤️ Give it a heart
- 🔖 Bookmark for later
- 🔄 Share with your dev friends
- 👤 Follow me for more AI development insights
Built for the #Kiroween Frankenstein Hackathon 2024
Tags: #kiro #AI #GameDev #MultiAgent #Groq #NextJS #LLM #TTS #AgentDriven #Frankenstein
🎃 About the Hackathon
This project was built for Kiro's Frankenstein category: "Stitch together a chimera of technologies into one app." We combined:
- 5 LLM agents (Groq)
- 4 TTS providers (Azure, Google, Play.ht, Gemini)
- AI-generated art (Gemini)
- AI-generated music (Suno)
- Custom MCP servers
- 3 development paradigms
The result? Something unexpectedly powerful - just like Frankenstein's monster.
Appendix: Technical Deep Dive
Agent Architecture
Each agent has:
- Name - Display name
- Personality - One-line description
- System Prompt - Detailed behavior definition (under 30 words per response)
- Voice - Unique Azure TTS neural voice
Debate Flow
1. Player triggers hint request
2. API route receives puzzle context
3. 5 parallel Groq API calls (Promise.all)
4. Each agent responds independently (temperature=0.8)
5. Elara synthesizes consensus from all perspectives
6. Responses spoken with unique voices (Azure TTS)
7. Display in real-time to player
Steering Document Strategy
Key insight: Define relationships, not just traits.
Bad steering:
Elara is maternal
Harlan is logical
Good steering:
When debating:
- Mira sides with emotional choices
- Harlan provides logic but defers to family
- Selene demands honesty
- Elara synthesizes consensus
The second approach creates authentic family dynamics.
Performance Notes
- 5 parallel API calls: ~2-3 seconds total (Groq is FAST)
- Azure TTS caching: Repeated phrases cached locally
- Music streaming: 15% volume, seamless loops
- Image optimization: Next.js Image component with priority loading
Future Improvements
- Memory system: Agents remember previous conversations
- Emotional state: Agents' moods change based on player choices
- Branching narrative: Multiple endings based on agent consensus
- Voice cloning: Custom voices for each character
- Real-time animation: Lip-sync with TTS output
Thanks for reading! If you found this helpful, give it a ❤️ and follow me for more AI development insights.
Top comments (0)