Handoff: Vitto Orchestration Completeness — OpenClaw Parity Audit

For Session 139 | Created February 23, 2026

Context

The user observed that backend-vitto-api is supposed to function like OpenClaw — an open-source AI agent orchestration framework (100k+ GitHub stars, Feb 2026) that provides a gateway, agentic loop, skills, MCP, persistent memory, multi-agent coordination, and monitoring.

A quick audit of apis/backend-vitto-api/src/app/ confirms all 7 capabilities exist as code:

The problem: These capabilities may exist in isolation. Session 138 revealed that the module generation pipeline (the most visible user-facing feature) was completely disconnected from the frontend, had half-built deployment, and crashed from type mismatches. If the flagship pipeline was this broken, the broader orchestration system likely has similar integration gaps.

What the Next Agent Should Investigate

1. Is the Agentic Loop Actually Used?

The module-generation/ pipeline runs a fixed 7-phase sequence (ENHANCE→ANALYZE→DECOMPOSE→PLAN→EXECUTE→INTEGRATE→DEPLOY). It does NOT use the AgentLoopService from engine/agent-loop.service.ts.

Question: Should module generation use the agentic loop instead of a hardcoded phase sequence? OpenClaw's agents reason about what to do next — they don't follow a fixed script. The agentic loop could:

• Decide whether to skip phases based on prompt complexity
• Retry failed phases with different strategies
• Dynamically add phases (e.g., "this needs a data migration step")

2. Are Skills/Tools Registered for Module Generation?

The tools/tool-registry.service.ts and engine/skill-manager.service.ts exist, but does the module generation pipeline register its capabilities as tools? In OpenClaw, each capability is a "skill" that any agent can invoke. If module generation isn't registered as a skill, other agents can't delegate generation tasks.

Check: Are there tool definitions in mcp-server/ for generation? Can the agentic loop invoke module generation as a tool?

3. Does Multi-Agent Actually Work?

a2a/ implements the Google Agent-to-Agent protocol. engine/delegation-manager.service.ts handles agent-to-agent messaging.

Questions:

• Has this been tested with real agent-to-agent communication?
• Can one Vitto instance delegate a sub-task to another?
• Is there session sharing between agents (OpenClaw's sessions_list, sessions_history, sessions_send)?
• Is the A2A bridge connected to the frontend or is it backend-only?

4. Is Memory Integrated with Generation?

mind/vitto-memory.service.ts provides vector-embedded persistent memory. But does the module generation pipeline USE it?

Questions:

• When generating a "Fitness Studio" platform, does Vitto recall past fitness studio generations?
• Does it learn from successful vs failed generations?
• Are generation outcomes stored as memories for future retrieval?

5. Cost Guard and Strategy

strategy/cost-guard.service.ts exists. OpenClaw discovered that 10 agents running 24/7 creates 10-50x cost escalation.

Questions:

• Is the cost guard active during module generation?
• Are there per-agent budgets or per-generation cost caps?
• Does the smart router (llm/smart-router.service.ts) route cheap tasks to cheaper models?

6. End-to-End Flow Completeness

Session 138 fixed the module generation pipeline (frontend → Vitto → backend-ai-api). But module generation is just one "skill." The complete orchestration should support:

• Chat-driven generation: User says "build me a fitness app" in chat → Vitto routes to module generation
• Proactive suggestions: Vitto monitors user behavior and suggests modules
• Cross-module actions: Generated module A needs data from module B → delegation
• Deployment orchestration: Generated code → GitLab → Cloudflare → live URL

Question: Which of these flows actually work end-to-end vs exist only as infrastructure?

OpenClaw Reference Architecture

For comparison, OpenClaw's architecture:

User → Gateway → Agent Reasoning Loop
                  ├── Skills (file ops, shell, email, web, calendar)
                  ├── MCP Tools (extended capabilities)
                  ├── Memory (vector-embedded, persistent)
                  ├── Agent-to-Agent (session sharing, delegation)
                  └── Monitoring (ClawDeck — sessions, logs, alerts, costs)

Key OpenClaw differentiators:

• Agents REASON about what to do next (not fixed pipelines)
• Skills are dynamically registered and discovered
• Sessions are shareable between agents
• ClawDeck provides a management dashboard for agent fleets
• Cost guards prevent runaway spending

Files to Read

Session 138 Context (What Was Fixed)

The coding agent fixed the following in Session 138 — the next agent should NOT re-investigate these:

1. Frontend→Vitto wiring: workflow-state.service.ts now calls Vitto's GET /module-generation/start SSE endpoint instead of Pipeline A
2. DEPLOY phase completion: Vitto now calls deploy-modules on backend-ai-api after persisting modules
3. enhancedPrompt crash: Fixed type mismatch (object vs string) with getEnhancedPromptTitle() helper
4. Systemic type mismatches: Added normalizer functions for ANALYZE, DECOMPOSE, PLAN phases
5. SSE event translation: Frontend translates module-gen.* events to phase_start/workflow_complete format

Deliverables Expected

1. Gap analysis document: What works end-to-end vs what's infrastructure-only
2. Integration map: Which services call which, and where the chains break
3. Priority recommendations: What to wire up first for maximum user impact
4. Comparison table: Vitto vs OpenClaw feature-by-feature with status (working/exists-but-broken/missing)

MCP Decisions from S138

Query find_similar({ query: "pipeline orchestration vitto generation" }) for full decision history.