Skip to content

roadmap.md

Latest commit

 

History

History
247 lines (187 loc) · 11 KB

roadmap.md

File metadata and controls

247 lines (187 loc) · 11 KB
Raw

YAAOS Development Roadmap

Project: YAAOS (Your Agentic AI Operating System) Status: Active Development Start Date: 2026-03-13 Last Updated: 2026-03-15

Phase Overview

Phase 1 ──▶ Phase 1.5 ──▶ Phase 2 ──▶ Phase 3 ──▶ Phase 4 ──▶ Phase 5 ──▶ Phase 6
  SFS         SFS v2       Model       System      Agentic      Desktop     Arch
 (MVP)      (Production)    Bus        Agentd       Shell         DE        ISO
  ✓            ✓            ✓           ✓

Phase 1: Semantic File System (MVP) — DONE

Goal: A working semantic search tool — drop files in a folder, search by meaning.

Platform: WSL / Linux Stack: Python 3.11+, uv, sentence-transformers, sqlite-vec

Milestone Deliverable Status
1.1 Project setup (uv, structure, config) Done
1.2 DB layer (SQLite + sqlite-vec schema) Done
1.3 Indexer (text extraction + chunking) Done
1.4 Embedding provider (local all-MiniLM-L6-v2 + abstraction) Done
1.5 File watcher daemon (watchdog) Done
1.6 Search engine (hybrid: vector + FTS5 + RRF fusion) Done
1.7 CLI tool (yaaos-find) Done
1.8 OpenAI provider plugin (config-based swap) Done
1.9 Tests & polish Done

Dependencies: None (standalone)

Phase 1.5: SFS v2 (Production-Ready) — DONE

Goal: Handle real-world 22GB+ folders at scale with multi-format support, smart chunking, and GPU acceleration.

Completed: 2026-03-15 | Version: 0.2.0 | Tests: 136 passing

Milestone Deliverable Status
A1 4-layer file filtering (.gitignore, .sfsignore, extension whitelist, size limit) Done
A2 Stat-based change detection (mtime_ns + size_bytes, xxHash128 fallback) Done
A3 Batch embedding with debouncing + parallel I/O Done
B1 Extractor registry with graceful degradation Done
B2 Document extractors (PDF, DOCX, PPTX, XLSX, EPUB, RTF) Done
B3 Media metadata extractors (EXIF, audio tags, video metadata) Done
C1 Chunker registry with extension → chunker mapping Done
C2 Tree-sitter AST-aware code chunking Done
C3 Section-aware Markdown/RST chunking Done
D1 3-signal RRF search (vector + FTS5 + path matching) with recency boost Done
D2 Voyage + Ollama provider plugins Done
D3 Daemon query server + periodic re-scan + GPU auto-detection Done
D4 136 tests, ruff-clean Done

SFS's Role in YAAOS

SFS is not just a search tool — it is the semantic memory layer that every higher layer depends on:

Layer How It Uses SFS
Model Bus SFS provides context for all AI calls — OS-level RAG. Any component needing relevant files queries SFS.
SystemAgentd Agents discover related files, dependencies, and docs without explicit paths. Agents gain situational awareness.
Agentic Shell Replaces find/grep/locate with intent-based search. "open everything related to login" just works.
Desktop Environment Powers context workspaces — the desktop auto-organizes by surfacing semantically related files to what you're working on.

Dependencies: None (standalone, consumed by all layers above)

Phase 2: Model Bus (Unified AI Runtime) — DONE

Goal: A single API that all YAAOS components use for AI inference, with pluggable providers.

Completed: 2026-03-15 | Version: 0.1.0 | Tests: 173 passing

Milestone Deliverable Status
2.1 Model Bus daemon (asyncio Unix socket, JSON-RPC 2.0, NDJSON) Done
2.2 Ollama provider (embedding + generation + chat, streaming) Done
2.3 OpenAI provider (embedding + generation + chat, streaming) Done
2.4 Anthropic provider (generation + chat, streaming) Done
2.5 Voyage provider (embedding) + Local provider (sentence-transformers) Done
2.6 Provider routing + TOML config + .env support + CLI (yaaos-bus) Done
2.7 Resource manager (VRAM/RAM monitoring, LRU eviction, idle timeout) Done
2.8 Python client SDK (sync + async) with timeout and error handling Done
2.9 SFS ModelBus integration provider (routes embeddings through daemon) Done
2.10 Hot-reload config, systemd service files, graceful shutdown Done

Success Criteria (all met):

  • Any component can request embed() or generate() via socket
  • yaaos-bus config set defaults.generation openai/gpt-4o switches providers instantly
  • Model Bus prevents OOM by checking available VRAM/RAM before loading models
  • Streaming generation with back-pressure and broken pipe protection
  • 5 providers (Ollama, OpenAI, Anthropic, Voyage, local) — cloud + local

Dependencies: Phase 1 (SFS is the first consumer)

Phase 3: SystemAgentd (Agent Orchestration) — DONE

Goal: A supervisor daemon that manages AI agents as systemd services.

Completed: 2026-03-16 | Version: 0.1.0 | Tests: passing

Milestone Deliverable Status
3.1 SystemAgentd supervisor daemon (OTP-style supervision, reconciliation loop) Done
3.2 Agent service template (agent@.service) + crash socket + agents slice Done
3.3 Tool Registry — TOML manifests, JSON Schema validation, Jinja2 templates, bubblewrap sandbox (9 tools: docker, git, adb, gradle, sdkmanager, journalctl, systemctl, coredumpctl, pacman) Done
3.4 Log-Agent (real-time journald analysis with anomaly detection) Done
3.5 Crash-Agent (core dump analysis via coredumpctl, socket-activated) Done
3.6 Resource-Agent (CPU/RAM/GPU monitoring with predictive alerts) Done
3.7 Net-Agent (network anomaly detection via conntrack/ss) Done
3.8 Agent Bus API (JSON-RPC 2.0 Unix socket + systemagentctl CLI) Done
3.9 FS-Agent: SFS daemon wrapper managed via D-Bus/systemd Done

Success Criteria (all met):

  • Agents run as systemd services with cgroup isolation (yaaos-agents.slice: 30% CPU, 2GB RAM)
  • Crash-Agent analyzes core dumps and suggests fixes
  • Log-Agent surfaces anomalies from journalctl in real-time
  • systemagentctl status shows all running agents
  • Tool registry discovers and invokes CLI tools (docker, git, adb, etc.)
  • SFS runs as FS-Agent under supervisor management

Dependencies: Phase 2 (agents use Model Bus for inference)

Phase 4: Agentic Shell (aish) ← NEXT

Goal: An intent-driven shell that understands natural language commands.

Deferred from Phase 3:

  • Daemon-mode DI wiring — run_daemon() should inject a supervisor-owned AsyncModelBusClient (and optionally ToolRegistry, SfsClient) into Supervisor(), enabling supervisor-level health probing of Model Bus. Infra is in place (Supervisor.__init__ accepts the kwargs, _start_agent passes them through); only the daemon call site needs wiring.
Milestone Deliverable
4.1 Shell prototype (bash/nushell wrapper + LLM intent layer)
4.2 Intent parser (NL → command plan via Model Bus)
4.3 Audit display (show generated commands before execution)
4.4 Session memory (infinite context, recall past commands)
4.5 Semantic pipes (`cat log
4.6 Integration with SFS (yaaos-find built into shell)
4.7 Integration with SystemAgentd (agent status in shell)
4.8 Multi-step task execution (plan → execute → verify → adapt on error)

Success Criteria:

  • compress python files and send to staging generates and executes correct commands
  • re-run yesterday's docker command but on port 8080 works via session memory
  • Standard shell commands still work normally (fallback to bash)

Dependencies: Phase 2 (Model Bus), Phase 3 (agent integration)

Litmus Test: "Setup Android app and run it"

The ultimate validation that YAAOS works end-to-end. A single natural language prompt should:

User: "Setup a basic Android app repo with latest tech stack, install whatever is needed,
       build it, run it on an emulator, and verify it launches."

What YAAOS does (no GUI needed):

  1. Agentic Shell parses intent → generates a multi-step plan
  2. Tool Registry provides: sdkmanager, avdmanager, gradle, adb, emulator
  3. Agent installs Android SDK via sdkmanager (if missing)
  4. Agent scaffolds Kotlin/Compose project (template or LLM code-gen)
  5. Agent creates AVD via avdmanager + starts headless emulator (emulator -no-window)
  6. Agent builds with ./gradlew assembleDebug
  7. Agent deploys with adb install + launches with adb shell am start
  8. Agent verifies launch via adb shell dumpsys activity (no vision needed)
  9. Agent reports success/failure with logs

Test pass criteria:

  • Fresh system, single prompt, app running on emulator within 10 minutes
  • Agent recovers from at least one error (missing SDK component, build failure) without user intervention
  • adb shell dumpsys activity | grep "mResumed=true" confirms app is in foreground

Phase 5: Desktop Environment

Goal: Context-driven dynamic workspaces managed by AI.

Milestone Deliverable
5.1 Choose DE base (Wayland compositor: sway/river/custom)
5.2 Context workspace manager (Coding, Research, Gaming)
5.3 Automatic resource suspension (freeze inactive contexts)
5.4 Natural language window management
5.5 Ambient context awareness (window + file + browser)
5.6 Notification system for agent alerts

Success Criteria:

  • Switching from "Gaming" to "Coding" context frees RAM from suspended apps
  • "Put terminal left, browser right, browser wider" works
  • Agent notifications appear as desktop notifications

Dependencies: Phase 3 (agents), Phase 4 (shell integration)

Phase 6: Arch Linux Distribution

Goal: A bootable, installable YAAOS ISO built with archiso.

Milestone Deliverable
6.1 archiso profile (package list, custom configs)
6.2 Custom pacman repository for YAAOS packages
6.3 Calamares installer integration
6.4 GPU auto-detection (Vulkan default, CUDA/ROCm optional)
6.5 First boot experience (guided setup, model download)
6.6 Live USB demo mode
6.7 Documentation + website

Success Criteria:

  • Boot from USB → install → working YAAOS with all components
  • GPU detected and configured automatically
  • First boot wizard downloads chosen LLM model via Ollama
  • All phases (SFS, agents, shell, DE) work out of the box

Dependencies: All previous phases

Cross-Cutting Concerns

Concern Approach
Privacy Local-first. Cloud providers are opt-in. No telemetry.
Performance Embedding < 500ms/file. Search < 200ms. Agent CPU < 10%.
Security No arbitrary code execution without user confirmation. Sandboxed agents.
Testing Unit tests per component. Integration tests per phase.
Language migration Python MVP → Rust production (per component, not all at once).