Vitto Unified Autonomy Engine — Progress Timeline

For: Non-technical stakeholders Session: S240 | Date: March 19, 2026 Status: Complete

What Is This?

Vitto is our AI assistant that helps users and teams with tasks — from answering questions to running code to managing deployments. Before this work, Vitto had three limitations:

1. It couldn't do things on its own. It could answer questions and suggest actions, but couldn't actually run code, install software, or manage files in a safe environment.
2. Its permission system was rigid. A developer always got the same level of autonomy regardless of whether Vitto had a track record of success with that person.
3. It was purely reactive. Vitto waited for you to ask — it never anticipated your needs.

Session 240 fixes all three by building the Unified Autonomy Engine.

Timeline of Changes

Step 1: Giving Vitto Hands (VM Execution Layer)

What changed: Vitto can now run commands, write files, and manage code in its own isolated virtual machine — a small, secure computer dedicated to each user.

Why it matters: Previously, Vitto could only think and talk. Now it can do. If you ask "run the test suite," Vitto actually runs it and reports results — instead of just telling you the command to copy-paste.

How it works for users:

• Each user gets a personal workspace that remembers their setup (credentials, tools, preferences)
• When you need Vitto to do something, it restores your workspace in under 1 second
• When you're not using it, the workspace goes to sleep to save resources
• Everything runs in isolation — one user's work can never affect another's

Business impact: 10x cost reduction vs keeping workspaces always running. Users experience near-instant response (500ms) without paying for 24/7 compute.

Step 2: Teaching Vitto Judgment (Adaptive Trust)

What changed: Vitto now earns autonomy through demonstrated reliability, just like a human colleague.

Why it matters: Before, permissions were one-size-fits-all. A brand-new user and a power user with months of successful interactions got the same treatment. Now Vitto adapts:

Key safeguards:

• Trust is earned slowly (max 1 level increase per week)
• Trust is lost quickly (one critical mistake drops it immediately)
• Trust is specific — being trusted to search documents doesn't mean being trusted to execute code
• Users always have a minimum trust floor they control

For users: Vitto starts cautious and gets better at helping you over time. It learns what you're comfortable with and adapts accordingly.

Step 3: Making Vitto Proactive (Trigger Learning)

What changed: Vitto learns your patterns and anticipates your needs.

Why it matters: Instead of waiting for "check the build status" every morning at 9am, Vitto notices the pattern and starts doing it automatically — reporting results before you even ask.

How it works:

1. Vitto notices you've asked for the same type of thing 3+ times in the past 2 weeks
2. It creates a "trigger" — a learned pattern with low initial confidence
3. If you engage with the proactive action, confidence grows
4. If you dismiss it, confidence drops (and eventually the trigger is deleted)
5. High-confidence triggers can execute automatically (if trust allows)

For users: Over time, Vitto becomes like a colleague who knows your routine. No configuration needed — it learns by watching.

Step 4: Making Vitto Resilient (Recovery & Delegation)

What changed: Two improvements:

Crash recovery: If Vitto is interrupted mid-task (server restart, network issue), it can resume from where it left off instead of starting over. It saves compact "checkpoints" as it works, so recovery is fast and accurate.

Task delegation: Vitto can now break complex tasks into subtasks and assign them to specialized sub-agents. For example, when reviewing a pull request, Vitto might delegate code quality checking to one sub-agent and security scanning to another — working in parallel.

For users: Tasks don't get lost. Complex requests get handled faster because Vitto can divide and conquer.

What This Enables (Real Scenarios)

Scenario: "Just handle the deployment"

• You: "Deploy the latest changes to staging and run tests"
• Vitto checks its trust level for you on code execution — you're at Direct (earned over weeks)
• Vitto claims your VM workspace (restored in 500ms), runs git pull, yarn install, yarn test
• If it crashes mid-deploy, it resumes from the last checkpoint
• Reports results via your preferred channel (Slack, WhatsApp, web)

Scenario: "I know you'll need this"

• Vitto noticed you check CI status every morning
• At 8:55am, Vitto proactively runs the check
• Reports via WhatsApp before you open your laptop
• You engage with the message → Vitto's confidence in this trigger increases

Scenario: "Review this PR thoroughly"

• Vitto spawns 3 sub-agents: code reviewer, security scanner, test runner
• Security scanner spawns its own sub-agent for dependency CVE checks
• All work in parallel, results synthesized into one report
• Total: 4 agents working simultaneously, coordinated by Vitto

Numbers

What's Next

Compatibility

This work was built concurrently with Session 239 (Vitto Memory System v2). The two systems are designed to complement each other:

• Memory v2 makes Vitto remember better (who you are, what you've discussed)
• Autonomy Engine makes Vitto act better (what to do, when, and how autonomously)

No conflicts between the two systems. Several S239 features (conversation genome, token compression, cognitive plugins) directly benefit the Autonomy Engine.

Document generated as part of S240 session documentation. For technical details, see S240-unified-autonomy-engine.md.