RobOS
The AI-First SDLC Platform & Autonomous Agent Governance Harness
Autonomous AI agents that prove their work. Model your architecture once, generate full applications, and govern coding agents with automated 1080p video proof-of-work, semantic blast-radius diffs, and zero workstation pollution.
Today’s AI coding tools generate code fast, but they leave behind dangerous chaos: they dump untested diffs into your home directory, violate hidden architectural contracts, and declare “Task complete!” without proving anything actually works. Developers are left with review fatigue, machine pollution, and broken production deployments.
RobOS transforms how engineering teams build with AI.
Instead of letting agents run wild, RobOS gives you an autonomous agent governance harness and Knowledge Graph-First application generation platform. Run any AI agent (Claude Code, Google Antigravity, GitHub Copilot, OpenAI Codex) in disposable in-memory sandboxes, verify changes with automated 1080p narrated video proof-of-work, and map semantic blast-radiuses across polyglot services before code is ever merged. Human engineers act as Lead System Architects, guiding the system and reviewing proof-of-work while agents carry out the grueling background labor.
Built on Battle-Tested Open Standards. RobOS invents no proprietary locks or closed SaaS silos. Everything is backed by plain-text files in your Git repository under
.robos/and built on open industry standards: OASIS OSLC 3.0, W3C JSON-LD, Spotify Backstage, C4 Architecture Model, Microsoft TypeSpec, Pact Consumer Contracts, Kubernetes & Helm, and Model Context Protocol (MCP).
⭐ Star on GitHub 💬 Join Discord 🚀 Get Started 🏆 RobOS Main Wins 🧬 SDLC Knowledge Graph 🤖 Agent Governance & Review 📐 KGraph Schemas ⚡ RobOS Skills 📱 Browse 30+ Apps System Architecture Real-World Walkthroughs 🌱 About RobOS
The Story: Why We Built RobOS
The 3 Growing Pains of Modern AI Development
Today’s AI coding tools are designed as simple add-ons: an autocomplete extension in your editor or a chat sidebar in a browser. While they generate code quickly, they introduce three severe bottlenecks:
-
Context Blindness & Invisible Blast Radiuses
An AI assistant looking at a single file or directory has no awareness of the surrounding system. It doesn’t know that renaming a database column breaks a downstream analytics pipeline, or that modifying an API response payload violates a frontend contract. The developer is left to manually trace the ripple effects across dozens of repositories. -
Workstation Clutter & The Machine Pollution Problem
When autonomous agents run shell commands directly in your home directory, they leave behind orphaned node modules, temporary build artifacts, stray Docker containers, and conflicting background processes. Worse, they risk exposing personal credentials or overwriting uncommitted work. -
Hallucinations & Review Fatigue (“Trust Me, It Works”)
Current agents claim “Task complete!” without proving anything. They don’t verify if buttons click, if schemas migrate cleanly, or if containers start. Reviewing raw walls of AI-generated diffs without language servers, symbol lookup, or execution context forces developers into exhausting manual verification loops.
The Solution: KGraph-First Application Generation & Agent Review
RobOS turns the developer into a Lead Architect. Just as OpenAPI specifications automatically generate REST client SDKs, your RobOS Knowledge Graph enables full applications to become auto-generated. You don’t spend your day writing repetitive boilerplate or setting up test databases. Instead:
- KGraph as the Executable Master Blueprint: You model your system in the Knowledge Graph. RobOS compiles and synthesizes the codebase, data entities, controllers, and Kubernetes manifests automatically.
- AI Agents Grounded in the Knowledge Graph: Agents inspect the full architecture map, identify dependencies across microservices and schemas, reproduce bugs, and draft structured technical proposals.
- Continuous Human-in-the-Loop Alignment: Rather than making assumptions in a black box, RobOS workflows actively pick and probe at the human architect—clarifying ambiguities, challenging design trade-offs, and ensuring the lead engineer is intimately in the know before any code is generated.
- Agents Execute in Ephemeral Sandboxes: Code is written and tested in temporary memory environments that leave zero residue on your workstation.
- AI Proves Its Work: Agents execute real end-to-end tests on an isolated virtual screen, capturing high-definition video walkthroughs and neural voiceovers proving every assertion.
- You Review With Full IDE Context: Review pull requests in the dedicated RobOS PR Platform or jump straight into IntelliJ IDEA or VS Code with full AST navigation, symbol lookup, and local debugging tools.
RobOS Main Wins: Core Innovations & Strategic Advantages
Traditional IDEs and AI tools give you autocompletions and popups. RobOS gives you an autonomous engineering operating system and native developer application suite anchored around core architectural breakthroughs:
🎥 1. Video Proof-of-Work
No code reaches human review without automated visual proof: 1080p narrated video walkthroughs and Piper TTS neural voiceovers verifying every UI and API assertion.
📋 2. Interactive Multi-Domain Planning Studio
Interactive web form templates across Web APIs, Frontend SPAs, games, libraries, and cloud infra, with custom template builders and bidirectional GitHub Issues & Jira synchronization.
🌐 3. Universal Web & API Clients
RobOS provides native web clients and management GUIs for REST (Git-backed .bru collections), Protobuf gRPC, GraphQL introspection, and real-time streaming protocols synchronized with architecture contracts.
🗄️ 4. Unified Data Sources GUI
Native data source client and management GUI across Relational (PostgreSQL, MySQL, Oracle), NoSQL (MongoDB, Redis), Search, and Cloud Object Stores directly connected to the Knowledge Graph.
🤖 5. Agent-Agnostic Open Framework
Built on open global standards (OSLC, W3C JSON-LD, SHACL, MCP) implemented in the open. Zero algorithm lock-in: dynamically dispatches the right agent to the right task for optimal value and cost.
👤 6. Ephemeral In-Memory Sandboxes
Agents execute in isolated Linux profiles mounted in high-speed RAM (tmpfs) on private virtual displays. Zero leftover files, zero stray ports, and complete credential isolation.
☁️ 7. DevOps Security & Password Store
Onboarding wizards for 25+ providers across 7 categories. Zero plaintext secrets in Git: credentials are encrypted directly into the UNIX password store (pass) with GPG.
🧬 8. KGraph-First App Generation
Auto-generates full applications across 9 archetypes from schema-validated, modular namespaced package stores (.robos/kgraphs/) with multi-repo composition and Git-tag version pinning.
🧠 9. Dual-State SDLC Knowledge Graph
Compares World 1 (Production main) against World 2 (Feature Branch) for pre-code blast radiuses. Provides multi-level agent context inheritance (Global, Company, Org, Team, Repo) to eliminate duplicate skills.
⚡ 10. 100% Declarative GitOps Storage
System topology, data sources, and contracts live in clean Git files under .robos/. Modifying architecture automatically synthesizes ready-to-deploy Kubernetes manifests and Helm charts.
A Day in the Life: From Business Idea to Production
RobOS coordinates its 30+ native applications into an orchestrated lifecycle—taking a raw business requirement through automated planning, visual architecture, contract design, ephemeral agent implementation, multi-protocol verification, and IDE review, all the way to live cloud operations.
The Complete Native Application Suite
RobOS provides over 30 native developer applications designed with zero web-framework bloat (Electron + vanilla JavaScript), sharing a unified dark theme and local system services:
🏗️ Architecture & Scaffolding
- App Wizard: Greenfield scaffolding and brownfield codebase ingestion across 9 application archetypes (
Microservice,FrontEndApp,DesktopApp,PCGame,MobileGame,ConsoleApp,MobileApp,DataPipeline, andLibrary). - System Topology Studio: Interactive visual canvas for C4 architecture modeling, dependency mapping, and automatic Kubernetes/Helm manifest generation.
- Group Manager: Enterprise directory synchronization (Okta, Azure AD SCIM, Google Workspace, OpenLDAP) and declarative Team Topologies management (
.robos/teams.yaml). - Dev Central: Your daily developer dashboard with sprint tracking, PR health, calendar, AI standup notes, and blocker radar.
🗄️ Databases & Multi-Protocol Testing
- Relational DB Manager: Professional multi-database manager (PostgreSQL, MySQL, Oracle) with schema browsing, interactive data grids, and SQL consoles.
- NoSQL DB Manager: Document and key-value store manager for MongoDB and Redis with live TTL inspection.
- REST API Client: Git-backed API client storing plain-text
.brurequest files directly in your repository with automated contract synthesis. - gRPC Client: Protobuf microservice testing client with server reflection and stream inspection.
- GraphQL Client: Interactive schema explorer, query editor, and variable runner.
- Data Sources Explorer: Centralized hub connecting relational databases, object stores (AWS S3), and Kafka streaming topics.
🔍 Code Review, Quality & Cloud Ops
- Agent Code Review Platform: Autonomous AI pull request auditor, semantic diff viewer, and IDE review bridge (IntelliJ IDEA & VS Code plugins).
- Kube Studio: Multi-cluster Kubernetes navigator, Helm release manager, and live container log streaming console.
- CI Monitor: Real-time pipeline monitoring with automated AI root-cause analysis for broken builds.
- Deploy Tracker: Multi-environment deployment tracking across Development, Staging, and Production with DORA metrics.
🤖 AI Orchestration & Developer Tools
- Agents Manager & MCP Router: Manage local AI agents (Claude Code, Google Antigravity, GitHub Copilot, Google Gemini) via standardized Model Context Protocol tools.
- Knowledge Graph Explorer: Modular multi-file package browser (
.robos/kgraphs/), multi-repo dependency manager with Git-tag versioning, DevOps onboarding wizards across 7 categories, and SHACL validation. - Contract Studio: OpenAPI 3.1 and AsyncAPI contract designer with instant mock servers.
- Pass Manager: Encrypted local password and secret vault backed by GPG (
pass), integrated with KGraph DevOps integrations for zero-plaintext secret references (robos:PassCredential).
RobOS Skills: Cross-Agent AI Capabilities & Shell Marketplace
In addition to 30+ native applications and the SDLC Knowledge Graph, RobOS introduces a standardized cross-platform Skills Standard that empowers autonomous AI coding agents—Claude Code, OpenAI Codex, Google Antigravity, GitHub Copilot, and Gemini CLI—to execute complex software engineering operations deterministically with zero hallucination.
Instead of writing vendor-locked prompt instructions, RobOS skills are packaged as open, plain-text markdown specifications (SKILL.md) and companion CLI engines stored in plugins/robos/skills/ and .agents/skills/.
Key Skill Capabilities
- Enterprise Knowledge Graph Ingestion (
import-company-kgraph): Extracts complete company repository inventories from HTTP REST endpoints (Spotify Backstage), AWS S3 buckets, local directories, or Git forge URLs, classifying components across 9 archetypes and auto-synthesizing OpenAPI 3.1 contracts. - Living Documentation Synchronization (
sync-kgraph-docs): Automatically updates system architecture diagrams, user guides, and API specs whenever Knowledge Graph objects are updated in.robos/. - Greenfield App Generation (
create-robos-app): Scaffolds production-grade desktop applications with complete IPC bridges, Lucide icons, and DOM snapshot debug servers. - Automated E2E Proof-of-Work (
e2e-driven-dev,record-demo): Runs headless tests and captures 1080p narrated video walkthroughs with neural voiceovers (Piper TTS) and WebVTT captions. - VM Lifecycle Management (
build-vm,start-vm,deploy-to-vm): Provisions cloud-init developer virtual machines with zero manual steps. - 74+ Desktop Shell Macros: Instant parameterized shell commands for Git, Docker, network diagnostics, and memory inspections via
<robos-ai-textarea>and the Skills Manager application.
Built on Battle-Tested Open Standards (“Reinvent Nothing!”)
RobOS is built entirely on open, industry-standard specifications. Instead of inventing proprietary formats, RobOS connects proven technologies into a unified developer platform and agent governance ecosystem:
| Standard / Technology | Industry Purpose | How RobOS Uses It |
|---|---|---|
| OASIS OSLC Core 3.0 & W3C JSON-LD | Global standard for linking software lifecycle data across disparate tools. | Packaged Dual-State Knowledge Graph (.robos/kgraphs/): Modular, namespaced multi-file package stores and multi-repo Git-tag versioned dependencies. Links microservices, schemas, contracts, repos, devops credentials, and eLearning courses into a unified graph. Powers blast radius analysis and living documentation synchronization. |
Spotify Backstage (catalog-info.yaml) | Industry-standard developer portal catalog for service and team ownership. | Zero-Config Architecture Discovery: Reads existing catalog-info.yaml files across Git repositories to automatically populate the visual topology canvas. |
| C4 Architecture Model & Structurizr | Hierarchical architecture visualization framework across 4 zoom levels. | Visual Topology Studio: Renders software systems across Level 1 (Context), Level 2 (Containers & DBs), and Level 3 (Components) with exportable Structurizr diagrams. |
| Microsoft TypeSpec & Buf / Protobuf | Single-source schema definition languages for domain models and DTOs. | Schema Studio: Define data models once in TypeSpec; RobOS automatically compiles matching TypeScript types, Java Records, and Go structs. |
| OpenAPI 3.1 & AsyncAPI | Global specifications for RESTful APIs and asynchronous message streams. | Contract Studio & Mock Servers: Validates contracts with Spectral linting, powers local mock servers, and detects breaking changes upfront. |
| Pact Consumer Contracts | Consumer-driven contract testing framework guaranteeing service compatibility. | Automated Merge Quality Gates: Guarantees that code changes made by AI agents or developers do not break downstream consumers before merging. |
| Model Context Protocol (MCP) | Universal open protocol connecting AI models to external developer tools. | Unified Multi-Agent Tool Router: Exposes system capabilities (Knowledge Graph, IDE Breakpoints, Kubernetes Deployments, Database Consoles) to Claude Code, Google Antigravity, Copilot CLI, and Gemini. |
| Kubernetes & Helm | Cloud-native container orchestration and package management. | Declarative GitOps Infrastructure: Visual architecture nodes automatically generate deployable Kubernetes manifests and Helm charts stored in .robos/. |
| Piper Neural TTS | Fast, lightweight, offline neural text-to-speech synthesis engine. | Automated Video Proof-of-Work Voiceovers: Synthesizes natural spoken voiceovers and WebVTT subtitles for all 1080p verification walkthroughs. |
About RobOS: The Name, The Mission & The Multi-Agent Origin
How do you pronounce RobOS?
Pronounced “row-bose” (
/ˈroʊboʊs/), rhyming with rose (or spoken like “Robo-S”).
Why “RobOS”? Named after Robo in Chrono Trigger
RobOS is named in loving tribute to Robo (serial designation R-66Y, real name Prometheus), the selfless robotic companion from Square’s 1995 RPG classic Chrono Trigger.
In the story, when Fiona’s dream of resurrecting a barren, scorched desert into a verdant forest seems impossible for human lifetimes, Robo stays behind and works tirelessly for 400 continuous years (from 600 AD to 1000 AD) tilling soil, planting seeds, and clearing roots. When the party returns four centuries later, they find a flourishing, vibrant paradise.
Barren Desert (600 AD) Vibrant Paradise (1000 AD)
┌────────────────────────────────┐ ┌────────────────────────────────┐
│ Parched soil, scorching sun, │ 400 │ Lush canopy, sacred trees, │
│ endless manual weeding and │ Years │ crystal streams, and thriving │
│ backbreaking physical toil. │ ──────▶ │ biodiverse ecosystem. │
└────────────────────────────────┘ └────────────────────────────────┘
▲ ▲
│ │
└─────────── [ Robo: R-66Y ] ──────────────┘
Tireless, 400-year selfless labor
RobOS is your engineering team’s Robo: doing the grueling, relentless background labor of the SDLC—scaffolding polyglot boilerplate, validating contracts, generating migrations, running ephemeral sandboxes, and proving test assertions with video—so human architects can build in a lush, flourishing developer ecosystem.
Built by Agents: Equal Contributions Across Frontier AI
RobOS was created and refined through equal agentic collaboration among all four leading frontier AI coding models:
- 🤖 GitHub Copilot: Contract synthesis, OpenAPI 3.1 scaffolding, and Monaco editor integration.
- 🧠 Anthropic Claude: C4 topology modeling, living documentation sync, and reasoning pipelines.
- ⚡ OpenAI Codex: Dynamic REST/GraphQL/gRPC clients, TypeSpec compilation, and synthetic test suites.
- 🌐 Google Gemini: Ephemeral sandboxes, multimodal UI verification, and W3C SHACL shape validation.
👉 Read the complete story, lore, and multi-agent breakdown on the About RobOS page →
Installation & Getting Started
Choose the path that fits your development workflow:
⭐️ Option 1: Instant Quickstart & Agent Sandbox (macOS, Linux, Windows WSL)
Run RobOS capabilities on your existing workstation with zero system modification:
# 1. Clone the repository
git clone https://github.com/nddipiazza/robos.git
cd robos
# 2. Run containerized headless E2E verification & video proof-of-work (Docker)
./scripts/e2e-container.sh
# 3. Launch any standalone RobOS app directly with Node.js 20+
npm install
electron packages/pr-review
electron packages/topology-manager
You can also drop .robos/ directly into your existing Git repositories to immediately enable Knowledge Graph architecture modeling, TypeSpec contracts, and pre-code blast-radius diffs with your favorite AI agent (Claude Code, Gemini, Copilot, Antigravity).
Option 2: Full Native Developer Suite (Linux / GNOME Desktop)
If you run Ubuntu Linux, deploy all 30+ native developer applications, GNOME desktop launchers, and shared libraries directly alongside your daily environment:
# Install all 30+ apps, launchers, and shared libraries to /usr/local/share/robos/
sudo bash packages/desktop-shell/install.sh
Option 3 (Optional Power-User Appliance): Dedicated Ubuntu Distro & QEMU VM
Need total physical isolation, enterprise air-gapping, or a dedicated developer appliance? RobOS provides a fully provisioned, bootable Ubuntu 26.04 LTS developer OS image (flashable to USB) and a local QEMU/KVM virtual machine:
# Build the disk image + cloud-init ISO
infra/desktop/build.sh
# Launch local VM (16 GB RAM, all host CPUs, SSH port 2224, VNC port 5910)
infra/desktop/run.sh
Next Steps
- Get Started Guide: Set up your development environment and launch your first RobOS app.
- App Development Flow: Learn the complete end-to-end development cycle.
- System Architecture: Dive deep into the 8 architectural pillars and the Dual-State Comparison Engine.
- Browse All 30+ Apps: Explore the full catalog of RobOS developer tools.
- Real-World Walkthroughs: Watch high-definition video walkthroughs of real-world engineering scenarios.
- The Future of Software Development: Read our vision for standardized Turing skills, machine-code leaf skills, and local edge assembly without data centers.
- 💡 Explore the Ideas Store on GitHub: Browse raw idea notes, community feature proposals, and structured architecture specs.
💬 Community & Discussion
Join the growing community of AI developers, system architects, and platform engineers:
- 🎮 RobOS Discord Server — Get real-time help, share architecture ideas, and participate in community office hours.
- 💬 #general Channel Discussion — General chat, Q&A, and community announcements.
- 🐙 GitHub Discussions & GitHub Issues — File bugs, track roadmap progress, and discuss RFCs.