published: true
description: "Why we stopped improving how AI responds and started governing how AI decides. A Multi-Agent RAO system that validates before analyzing, and plans before responding."
tags: ai, python, opensource, machinelearning
Two months ago, I published Tiramisu Framework v2.0 — a multi-agent RAO system with 100% routing accuracy.
Today, I'm releasing v3.0 — and it changes everything about how we think about AI systems.
The shift: We stopped improving how AI responds and started governing how AI decides.
🎯 TL;DR
What Tiramisu 3.0 does differently:
✓ Governs decisions BEFORE generating responses
✓ 3 personas collaborate (not compete)
✓ Validates sufficiency, not just capability
✓ Output = traceable plan, not loose text
Architecture:
Query → Validation → Analysis → Plan → Result
(RAO-4) (RAO-5) (RAO-6)
Install:
pip install tiramisu-framework==3.0.0
📊 The Problem: Generation Without Governance
Most AI frameworks focus on one thing: generating better responses.
Better prompts. Better models. Better retrieval. Better context.
But they skip a fundamental question:
Should the system respond at all? And if yes, how should it decide what to say?
Traditional frameworks:
StepWhat Happens1Receive query2Retrieve context3Generate response4Return to user
The problem? No governance. The system assumes it should always respond, with whatever data it has.
This works for chatbots. It fails for systems where decisions matter.
🏗️ Tiramisu 3.0: Governance First
Tiramisu 3.0 introduces a different architecture:
USER QUERY
│
▼
┌─────────────────────────────────┐
│ RAO-4: COLLABORATIVE │
│ VALIDATION │
│ │
│ "Do we have enough data for │
│ THIS type of problem?" │
│ │
│ Decision: PROCEED or BLOCK │
└─────────────────────────────────┘
│
▼
┌─────────────────────────────────┐
│ RAO-5: COLLABORATIVE │
│ ANALYSIS │
│ │
│ Router selects LEADER │
│ Others provide SUPPORT │
│ │
│ Output: Structured analysis │
└─────────────────────────────────┘
│
▼
┌─────────────────────────────────┐
│ RAO-6: COLLABORATIVE │
│ PLAN │
│ │
│ Each component → 1 action │
│ System prioritizes │
│ │
│ Output: Traceable plan │
└─────────────────────────────────┘
│
▼
GOVERNED RESULT
The key insight: Before any analysis or generation, the system validates sufficiency.
Not "can I respond?" but "do I have the right data for this specific type of problem?"
🔄 What Changed from v2.0 to v3.0
Aspectv2.0v3.0FocusRouting accuracyDecision governanceArchitectureSupervisor + AgentsCollaborative RAO levelsValidationAfter retrievalBefore analysisOutputResponseStructured planTraceabilityPartialComplete
v2.0 asked: "Which agent should handle this?"
v3.0 asks: "Should we proceed? With what confidence? Using which approach?"
🎭 Collaborative Personas
Tiramisu 3.0 uses three specialized personas that collaborate at each level:
PersonaFocusRoleKStrategyPositioning, fundamentals, segmentationMChannelsDigital presence, metrics, technologyGExecutionContent, speed, practical action
Important: These personas don't debate freely. Each has a fixed role per RAO level:
RAO-4: Each validates its own area
RAO-5: One leads, others support
RAO-6: Each contributes one action
This structured collaboration prevents the chaos of open-ended multi-agent debates.
🚦 RAO-4: Sufficiency Validation
The first level doesn't ask "can we help?" — it asks "do we have enough?"
Query: "My product isn't selling well"
RAO-4 Validation:
┌────────────────────────────────────────┐
│ Persona K: Checking strategy data... │
│ ⚠️ Missing: competitor analysis │
│ ⚠️ Missing: price positioning │
│ ✓ Has: target market │
│ │
│ Persona M: Checking channel data... │
│ ⚠️ Missing: current metrics │
│ ✓ Has: channel preferences │
│ │
│ Persona G: Checking execution data... │
│ ✓ Has: product description │
│ ✓ Has: brand voice │
└────────────────────────────────────────┘
Decision: APPROVED (medium confidence)
Gaps identified: 13
Recommendation: Proceed with caveats
Confidence levels:
LevelMeaningActionHIGHSufficient dataProceed normallyMEDIUMPartial dataProceed with caveatsVERIFYInsufficientRequest more dataBLOCKEDCannot proceedStop execution
🎯 RAO-5: Leader Selection
After validation, the system selects a leader based on query type:
Query analyzed: "My product isn't selling well"
Routing:
┌────────────────────────────────────────┐
│ Method: keywords │
│ Detected: sales, product, positioning │
│ │
│ Decision: │
│ LEADER: Persona K (strategy focus) │
│ SUPPORT: Persona M, Persona G │
└────────────────────────────────────────┘
Cascading router:
Keywords — Fast pattern matching
Embeddings — Semantic similarity (if keywords fail)
Fallback — Default assignment
The leader drives the analysis. Supporters add perspective without taking over.
📋 RAO-6: Structured Plan
The final level produces a traceable plan, not loose text:
RAO-6 Output:
┌────────────────────────────────────────┐
│ PRIORITIZED ACTION PLAN │
│ │
│ P1: Define strategic positioning │
│ Owner: K | Timeline: 30 days │
│ │
│ P2: Activate priority channels │
│ Owner: M | Timeline: 14 days │
│ │
│ P3: Create authentic content │
│ Owner: G | Timeline: 7 days │
│ │
│ Quality Score: 100% │
│ Actions: 3 | Priorities: [1, 2, 3] │
└────────────────────────────────────────┘
Why this matters:
Each action has an owner (traceable)
Each action has a timeline (accountable)
The plan has a quality score (measurable)
💻 Quick Start
bashpip install tiramisu-framework==3.0.0
pythonfrom tiramisu import GovernanceOrchestrator
Initialize
orchestrator = GovernanceOrchestrator()
Provide context
context = {
'product': 'artisan coffee',
'target_market': 'urban professionals'
}
Execute with governance
result = orchestrator.execute(
'My product is not selling well',
context
)
View governance logs
print(orchestrator.display_logs(result))
Output:
TIRAMISU 3.0 - Decision Governance
RAO-4 Collaborative Validation
Confidence: medium | Gaps: 13 | Decision: APPROVEDRAO-5 Collaborative Analysis
Leader: K | Method: keywords | Support: [M, G]RAO-6 Collaborative Plan
Actions: 3 | Quality: 100% | Priorities: [1, 2, 3]
📊 Metrics
MetricValueNew modules16Lines of code804Personas3RAO levels3Test coverage100%
🎯 Key Innovations
- Governance Before Generation The system decides if, how, and with whom to respond before generating anything.
- Sufficiency-Based Validation Doesn't ask "can I respond?" but "do I have enough data for this type of problem?"
- Structured Collaboration Personas don't chat freely. Each has a fixed role per level. No chaos.
- Complete Traceability Every decision generates a log. You know why the system decided that way.
- Contractual Output Result isn't text. It's a structured plan with owners, timelines, and scores.
✅ When to Use Tiramisu 3.0
Systems that need to explain decisions
Domains with multiple perspectives
Applications requiring prior validation
Projects that value traceability over speed
❌ When NOT to Use
Simple Q&A chatbots
Systems that don't need auditing
Applications where speed matters more than governance
🚀 What's Next
Short-term:
Documentation expansion
More routing strategies
Community feedback integration
Medium-term:
Advanced routing strategies
Enterprise governance features
Audit trail exports
Long-term:
Domain-specific persona templates
Enterprise governance features
Audit trail exports
📚 Resources
PyPI: https://pypi.org/project/tiramisu-framework/
GitHub: https://github.com/tiramisu-framework/tiramisu
Previous article (v2.0): https://dev.to/tiramisuframework/from-rag-to-rao-level-6-how-i-evolved-tiramisu-framework-into-a-multi-agent-system-4ebh
🎯 Key Takeaway
"We don't innovate in generation. We innovate in decision governance."
The future of AI systems isn't about generating better responses.
It's about governing better decisions.
Tiramisu 3.0 is a step in that direction.
Questions? Feedback? Drop a comment below.
What's your biggest challenge with AI decision-making? 👇
Top comments (0)