RobOS：AI-First SDLC 平台与自主智能体治理框架

RobOS — AI-First SDLC Platform & Autonomous Agent Governance Harness

Autonomous AI agents that prove their work. Model your architecture once, auto-generate polyglot applications, and govern coding agents with 1080p video proof-of-work, semantic blast-radius diffs, and zero workstation pollution.

Documentation · Quickstart · Core Innovations · App Suite · Architecture · Contributing · Discord Community

Complete Day-in-the-Life: from Onboarding Wizard & Dual-State Knowledge Graph to IntelliJ IDEA breakpoint debugging and Kube GitOps.
🎥 Watch the full 1080p video walkthrough (2:39)

⚡ The Problem: AI Agents Are Coding Blind

Today's AI coding assistants (Claude Code, GitHub Copilot, Cursor, OpenAI Codex, Google Antigravity) generate code at blistering speed, but they introduce severe risks that bottleneck engineering teams:

1. "Trust Me, It Works" (Review Fatigue): Agents claim "Task complete!" without verifying their work. Developers spend more time reviewing hallucinated diffs, broken imports, and failed edge cases than they would have spent writing the code from scratch.
2. Invisible Blast Radiuses: An agent working in a single file or repository has no visibility into the broader system. Renaming an entity breaks a downstream analytics pipeline; tweaking an API response violates a frontend consumer contract.
3. Machine Pollution & Host Mutation: Autonomous agents executing unchecked shell commands in your home directory leave behind orphaned node modules, zombie Docker containers, conflicting processes, and credential leak risks.
4. Unintentional Credential & Data Leakage: Developers pasting terminal logs, stack traces, or configs into AI prompts accidentally transmit AWS keys, GitHub PATs, database credentials, or customer PII into third-party LLM contexts. Agents are also exposed to prompt injection and credential exfiltration payloads.

RobOS fixes this by placing autonomous agents inside a verifiable governance harness.

🎯 The Killer Wedges

RobOS turns developers into Lead System Architects by wrapping autonomous agents in non-negotiable verification gates:

┌────────────────────────────────────────────────────────────────────────────────────────┐
│                                ROBOS GOVERNANCE HARNESS                                │
├──────────────────────┬──────────────────────────┬──────────────────────────┬───────────┤
│ 1. VIDEO PROOF-OF-   │ 2. DUAL-STATE SEMANTIC   │ 3. EPHEMERAL IN-MEMORY   │ 4. PROMPT │
│    WORK ENGINE       │    BLAST-RADIUS DIFFS    │    SANDBOXES (tmpfs)     │    SEC    │
├──────────────────────┼──────────────────────────┼──────────────────────────┼───────────┤
│ Headless Xvfb virtual│ Live graph diffing of    │ Zero host pollution.     │ Zero leak │
│ displays execute user│ World 1 (main) vs World 2│ Agents run in isolated   │ OSS rules │
│ flows and record 1080p (feature branch). Flags  │ in-memory Linux profiles │ (Gitleaks,│
│ narrated walkthroughs│ broken API contracts and │ with auto-teardown and   │ Presidio, │
│ with Piper TTS audio.│ Pact tests before code.  │ zero residual files.     │ OWASP).   │
└──────────────────────┴──────────────────────────┴──────────────────────────┴───────────┘

1. Automated 1080p Video Proof-of-Work

Stop reviewing walls of blind diffs. RobOS launches agents inside a headless Xvfb virtual framebuffer with Picom compositing. Agents execute the feature, interact with live UI elements, verify API responses, and record a 1080p text-narrated video walkthrough with synchronized neural voiceovers (Piper TTS). You approve PRs by watching a 15-second verifiable proof video.

2. Dual-State Semantic Blast-Radius Checking

Before generating code, RobOS compares your production architecture (World 1) against your proposed feature changes (World 2) in the SDLC Knowledge Graph. It traces transitive dependencies across services, databases, message brokers, and consumers—alerting you to breaking contract changes, schema regressions, and test failures before any code is merged.

3. Ephemeral In-Memory Sandboxes (tmpfs)

AI agents never execute raw commands directly in your daily workstation environment. RobOS isolates agent swarms inside ephemeral Linux user profiles mounted directly on in-memory tmpfs storage. When the task is complete, the sandbox evaporates—leaving zero machine residue, zero orphaned daemons, and zero credential leaks.

4. Zero-Data-Leak Prompt Security Guard (Gitleaks, Presidio, OWASP LLM01)

Never accidentally leak secrets or customer PII to external AI providers. RobOS intercepts every prompt in <robos-ai-textarea>, AgentSession, and EmbeddedHarnessRouter. It enforces open-source security standards: Gitleaks & TruffleHog secrets (AWS, GitHub, tokens, private keys, database URIs), Microsoft Presidio PII (Luhn-checked credit cards, SSNs, personal emails), Shannon entropy calculations, OWASP LLM01 prompt injection defenses, and 1-click in-place Auto-Redaction.

Knowledge graph classification

The Knowledge Graph Explorer defaults to a classification tree backed by one shared catalog for the engine and browser. Built-in classes, SHACL shapes and predicates have deterministic metadata. Nodes show declared or inferred classification; custom types with no known category remain visible as Unclassified with warnings. Package, RDF type and flat views, combined filters, search, and collapse counts remain available.

The object inspector also offers schema-specific tabs for recorded property groups: MCP servers and actions, services and contracts, application routes and commands, data models and databases, messaging, infrastructure, pipelines, source control, work items, testing, learning and agent configuration. Tabs require both an applicable type and actual data. Child objects are discovered through forward and inverse references; their declarations and source evidence are available without leaving the graph. Back/Forward navigation restores object visits, tabs and filters, including mouse side-button navigation. A bottom status bar identifies the graph and its location and counts. See the inspector guide.

RobOS owns the SDLC codes and expresses them using Schema.org CategoryCode and CategoryCodeSet. They are not a Schema.org SDLC taxonomy. See the classification and workspace guide for reference syntax, provenance, registry coverage, and the real Electron test.

Dependency impact uses directed, evidenced relationships and separates them from repository membership and source provenance. The importer records dependency scopes and protobuf references; unresolved external dependencies remain explicit. The topology view draws the same resolved JSON-LD relationships, with cyan dependency arrows, dashed reference arrows, and explicit limits on large views. Kube Studio can browse infrastructure declarations and their source evidence from the same graph workspace. See dependency workflows for commands, supported extraction and interpretation limits.

The object inspector shows recorded fields and JSON-LD. Documentation, source evidence, topology and dependency tabs appear only when the selected object has the corresponding data. Unrelated demo workflows and fabricated verification claims have been removed; see the tab audit.

🧬 The Paradigm: Knowledge Graph-First (KGraph-First) Application Generation

In modern software engineering:

• An OpenAPI 3.1 contract automatically generates typed REST clients and server stubs.
• A Protobuf definition automatically generates gRPC serializers and microservice stubs.
• An SQL DDL schema automatically generates typed ORMs and database migrations.

RobOS elevates this principle to the entire software application:

If an API contract can auto-generate a client, a schema-validated Knowledge Graph can auto-generate an entire application.

   ┌─────────────────────────────────────────────────────────────┐
   │             1. ARCHITECT IN KNOWLEDGE GRAPH                 │
   │   Define topology, services, schemas & contracts in .robos/  │
   └──────────────────────────────┬──────────────────────────────┘
                                  ▼
   ┌─────────────────────────────────────────────────────────────┐
   │           2. SYNTHESIS ENGINE & AGENT SWARMS                │
   │   Compiles graph into polyglot code, DB migrations & tests   │
   └──────────────────────────────┬──────────────────────────────┘
                                  ▼
   ┌─────────────────────────────────────────────────────────────┐
   │         3. EPHEMERAL SANDBOX EXECUTION & PROOF              │
   │   Builds, runs headless tests, and records 1080p video demo │
   └──────────────────────────────┬──────────────────────────────┘
                                  ▼
   ┌─────────────────────────────────────────────────────────────┐
   │         4. LEAD ARCHITECT REVIEW & 1-CLICK MERGE            │
   │   Inspect blast radius, watch video proof, approve in IDE   │
   └─────────────────────────────────────────────────────────────┘

RobOS supports auto-generation and governance across application archetypes:

• Microservices & Web APIs (robos:Microservice): OpenAPI 3.1 YAML, Protobuf gRPC, GraphQL.
• Frontend Web Applications (robos:FrontEndApp): React, Vite, Next.js, Vue, Svelte SPAs/SSRs.
• Desktop Applications (robos:DesktopApp): Electron, Qt, GTK, Tauri local applications.
• PC Games (robos:PCGame): Godot, Unreal Engine, Unity, Bevy desktop games.
• Mobile Games (robos:MobileGame): Cross-platform mobile games with touch controls.
• Console & CLI Tools (robos:ConsoleApp): Go Cobra, Rust Clap, Python Click, Node Commander utilities.
• Mobile Applications (robos:MobileApp): React Native, Flutter, iOS, and Android clients.
• Data Pipelines & Workers (robos:DataPipeline): Kafka Streams, Celery, Spark distributed workers.
• Shared Libraries & SDKs (robos:Library): Reusable client SDKs and common packages.

⚡ Quickstart (Universal: macOS, Linux, Windows, Docker)

Get up and running with RobOS in under 60 seconds on your existing machine:

1. Clone the Repository

git clone https://github.com/nddipiazza/robos.git
cd robos

2. Run Autonomous E2E Tests with Video Proof-of-Work (Docker)

Run the full headless verification harness inside an isolated container:

./scripts/e2e-container.sh

Captures DOM snapshots, executes integration tests, and generates proof-of-work video walkthroughs with zero host dependencies.

3. Launch Standalone Native Apps (macOS, Linux, Windows WSL2)

Run any RobOS desktop application using Node.js 20+:

# Install core dependencies
npm install

# Launch the Agent Code Review Platform
npx electron packages/pr-review

# Launch the System Topology Studio
npx electron packages/topology-manager

# Launch the Knowledge Graph Explorer
npx electron packages/kgraph-explorer

💡 Drop .robos/ into any repository: Add a .robos/ directory to your existing Git projects to immediately enable semantic Knowledge Graph architecture modeling, TypeSpec schemas, and pre-code blast-radius diffs with Claude Code, Google Antigravity, GitHub Copilot, or OpenAI Codex.

🧰 Native Developer Tool Suite (Apps)

RobOS includes a complete suite of lightweight, high-performance developer tools built with Electron and vanilla JavaScript (zero framework overhead). All tools are natively wired to your SDLC Knowledge Graph:

🔄 The Governance Workflow: Agent Review-Based Development

RobOS turns the traditional coding bottleneck on its head:

1. Grounded Investigation: The AI agent provisions an isolated workspace, investigates the requirement against the Knowledge Graph blueprint, reproduces edge cases at live breakpoints, and drafts an architectural proposal.
2. Proactive Human Alignment: RobOS actively probes the Lead Architect on design trade-offs, constraints, and edge cases before any code is generated—keeping humans in command.
3. Autonomous Implementation & Verification: The agent synthesizes the code, runs unit tests, provisions temporary test databases, and executes headless end-to-end tests on an isolated virtual screen.
4. 1-Click Human Approval in Your IDE: Review the blast radius diff and watch the 1080p narrated video proof. If you want deep code inspection, RobOS bridges the review directly into your existing IntelliJ IDEA or VS Code environment with full AST navigation, symbol lookup, and local debugging tools.

💻 Optional Power-User Appliance: Dedicated RobOS VM

For enterprise teams requiring total physical isolation, air-gapped workstations, or a dedicated developer appliance, RobOS provides a bootable Ubuntu 26.04 LTS OS image and QEMU/KVM virtual machine:

• Hardware Specs: 16 GB RAM, host CPU passthrough, 100 GB sparse disk.
• Desktop Environment: Custom GNOME desktop, dark navy/cyan theme, LightDM auto-login, Tilix terminal, zsh + oh-my-zsh.
• Total Isolation: Air-gapped sandbox with SSH (port 2224), VNC (port 5910), and SPICE (port 5932).
• Stateless Reproducibility: 100% automated first-boot provisioning via cloud-init.

# Build the disk image + cloud-init ISO
infra/desktop/build.sh

# Launch the QEMU/KVM Virtual Machine
infra/desktop/run.sh

(Note: The VM is entirely optional. RobOS runs natively on macOS, Linux, Windows WSL2, and Docker.)

🌐 Open-Source Standards ("Reinvent Nothing!")

RobOS is built entirely on battle-tested open specifications. Everything persists as declarative plain-text files in your Git repository under .robos/:

🤖 About RobOS (row-bose)

• Pronunciation: RobOS is pronounced "row-bose" (/ˈroʊboʊs/), rhyming with rose.
• The Lore: Named after Robo (R-66Y / Prometheus) from the 1995 RPG classic Chrono Trigger. In the story, Robo spends 400 years tilling and irrigating Fiona's scorched desert so it blossoms into a flourishing forest. RobOS does the same for developers: our autonomous agents tirelessly perform the grueling background labor of the SDLC (scaffolding, contracts, migrations, headless testing) so human architects can focus on creative engineering.
• Built by Agents: GitHub Copilot, Anthropic Claude, OpenAI Codex, and Google Gemini contributed equally to building RobOS through agentic workflows, proving that diverse AI models excel when collaborating under open standards.

👉 Read the complete backstory and multi-agent lore →

💬 Community & Discussion

Join developers, architects, and AI researchers building the future of agent-governed software development:

• 🛠️ Contributing Guide (Use RobOS to Build RobOS!) — Create prompt contracts, run workflows in community sandboxes, and submit video-proven PRs.
• 💡 Feature Ideas Store — Browse raw ideas, structured specs, and community prompt workflows.
• 🎮 Join the RobOS Discord Server — Live support, demo streams, and agent architecture discussions.
• 💬 #general Channel Discussion — General questions and community announcements.
• 🐙 GitHub Discussions & Issues — Feature proposals, bug reports, and roadmap discussions.
• 📖 Documentation Portal — Complete guides, architecture specs, and walkthrough archives.

_{Licensed under the Apache License 2.0. Copyright © 2026 RobOS Contributors.}