RobOS Skills & AI Agent Capabilities

How autonomous AI coding agents and human developers use standardized, cross-platform skills to automate the Software Delivery Lifecycle across Claude Code, OpenAI Codex, Google Antigravity, GitHub Copilot, and Gemini CLI.

Table of contents

  1. Overview: The RobOS Skills Architecture
  2. Two Interconnected Skill Layers
  3. Complete AI Agent Skills Catalog
    1. 1. Knowledge Graph (KGraph) Skills Suite
      1. Knowledge Graph CLI & Skill Invocation Examples:
    2. 2. Application Scaffolding & Component Lifecycle
    3. 3. Automated E2E Testing & Proof-of-Work
    4. 4. VM & Operating System Control
    5. 5. System Diagnostics & Marketplace Management
  4. Universal Cross-Agent Installation & Sync
    1. One-Click Synchronization
    2. Installing Globally
  5. Anatomy of a RobOS Skill (SKILL.md)
    1. Example: Standard SKILL.md Format
  6. Authoring New Skills with /manage-robos-skill
  7. The Skills Manager Desktop App (packages/skills-manager)
  8. The Future: Standardized Turing Skills & Compiled Machine Code
  9. Verification & Automated Testing
  10. Next Steps
📚 Complete Skills Catalog 🌐 Company KGraph Import Skill 🖥️ Skills Manager Desktop App

Overview: The RobOS Skills Architecture

In conventional development setups, AI coding assistants are trapped in vendor-specific silos. An instruction written for one CLI tool cannot be executed by another agent, and procedural knowledge on how to build, test, deploy, or inspect software is repeatedly lost.

RobOS unifies developer capabilities through the RobOS Skills Standard.

A RobOS Skill is an executable, portable capability packaged as open, plain-text markdown specifications (SKILL.md) and companion CLI engines. Skills provide deterministic, cross-agent workflows that teach any AI agent—as well as human engineers—how to carry out complex SDLC operations with zero guesswork.

RobOS Skills Standard & Marketplace Architecture
RobOS Skills Standard & Marketplace Architecture: Synchronizing vendor-agnostic AI agent skills and shell skills across Claude Code, OpenAI Codex, Google Antigravity, GitHub Copilot, and Gemini CLI. (Click image to zoom full screen)

Two Interconnected Skill Layers

RobOS provides two complementary layers of skills designed for developer productivity:

Layer Purpose Target Audience Storage Location Examples
AI Agent Skills (Plugin Marketplace) Complex, multi-step SDLC operations, code scaffolding, automated testing, E2E video proof-of-work, and Knowledge Graph synchronization Autonomous AI Coding Agents & Devs via CLI plugins/robos/skills/ and .agents/skills/ import-company-kgraph, sync-kgraph-docs, create-robos-app, e2e-driven-dev
Desktop Shell Skills (Skills Manager) Fast, parameterized bash commands and workstation diagnostic utilities Developers via GUI and <robos-ai-textarea> packages/skills-manager/skills-data.js 74+ shell skills across Git, Docker, Networking, Memory, and Storage

Complete AI Agent Skills Catalog

The RobOS Plugin Marketplace ships with standard skills categorized across the entire Software Delivery Lifecycle:

1. Knowledge Graph (KGraph) Skills Suite

Skill Slash Command Description What It Accomplishes
kgraph-search /kgraph-search <query> Semantic search across KGraph packages Searches components, databases, contracts, pipelines, and agent personas by keywords, types, or tags.
kgraph-insert /kgraph-insert <node> Insert architectural node with SHACL validation Registers new services, databases, or contracts into modular package stores (.robos/kgraphs/) with enforced SHACL validation.
kgraph-delete /kgraph-delete <nodeId> Safely delete node with cascade reference cleanup Decommissions deprecated microservices or databases and cleans up referencing edges across packages.
kgraph-update /kgraph-update <nodeId> In-place node mutation and property updates Updates OpenAPI contracts, database connections, or squad ownership with automatic SHACL re-validation.
kgraph-query /kgraph-query [filters] Graph query and multi-hop path traversal Queries nodes by RDF type or traces connection paths between two entities across microservices and contracts.
kgraph-impact-analysis /kgraph-impact-analysis <nodeId> Trace blast radius and dependent nodes Recursively analyzes inbound/outbound dependency edges to calculate blast radius before code or schema changes.
kgraph-validate /kgraph-validate [package] Enforce 100% W3C SHACL shape conformance Validates all packages in .robos/kgraphs/ against formal SHACL constraint shapes to guarantee 0 violations.
kgraph-diff /kgraph-diff [branch] Semantic blast radius diff (World 1 vs World 2) Compares Production main against feature branches to detect added, modified, or breaking architectural changes.
kgraph-export /kgraph-export [options] Export graph to standard RDF formats Exports Knowledge Graph packages to W3C JSON-LD 1.1, Turtle (.ttl), or N-Triples for external graph engines.
kgraph-visualize /kgraph-visualize [target] Generate Mermaid and C4 diagrams Produces executable Mermaid diagram syntax or component trees for any package or focused subsystem.
import-company-kgraph /import-company-kgraph Ingest company repository catalogs from HTTP, S3, or Git Ingests enterprise inventories from HTTP REST APIs, AWS S3 buckets, local directories, or Git forges into KGraph packages.
sync-kgraph-docs /sync-kgraph-docs Synchronize living documentation with graph updates Monitors graph mutations in .robos/ and automatically synchronizes markdown documentation and diagrams.

Knowledge Graph CLI & Skill Invocation Examples: 

# Search for microservices matching 'orders'
node packages/robos-graph/bin/kgraph-cli.js search "orders" --type robos:Microservice

# Trace blast radius and dependent components before editing a service
node packages/robos-graph/bin/kgraph-cli.js impact "urn:robos:service:forms-api" --depth 3

# Validate 100% SHACL conformance across all packages
node packages/robos-graph/bin/kgraph-cli.js validate

# Ingest an entire company repository catalog from an AWS S3 bucket
node plugins/robos/skills/import-company-kgraph/scripts/import-company-kgraph.js \
  --source s3://company-cloud-bucket/inventories/repos.json \
  --company-name "Acme Global" \
  --company-slug "acme" \
  --import-to-robos

2. Application Scaffolding & Component Lifecycle

Skill Slash Command Description What It Accomplishes
create-robos-app /create-robos-app <Name> Scaffold a new Electron desktop application Generates application workspace, main process, preload bridge, renderer UI, Lucide vector icon, DOM snapshot debug port, and registers across all 10 system manifests.
create-feature-spec /create-feature-spec <Idea> Convert a raw idea note into a structured specification Analyzes natural language ideas or prompts and generates rigorous engineering specifications in docs/ideas/specs/ with user personas, C4 models, and BDD scenarios.
create-test /create-test <Component> Generate unit and E2E test suites Author automated tests using the native robos-test framework, covering headless GUI testing and assertions.
add-ai-text-area-to-app /add-ai-text-area-to-app Embed <robos-ai-textarea> widget Integrates the streaming AI prompt bar with @-mention typeahead for files, repos, and shell skills.
update-app-icon /update-app-icon <App> <SVG> Update 48x48 Lucide vector SVG icon Validates 48x48 cyan vector graphics and synchronizes across robos-icons, icon-lib, and desktop shortcuts.
rename-robos-app /rename-robos-app <Old> <New> Safely rename an existing Electron app Propagates name changes across package directories, process managers, icon registries, and desktop files without breaking references.
remove-robos-app /remove-robos-app <App> Safely decommission and deregister an app Deregisters the application cleanly across all desktop managers, panels, and icon registries.

3. Automated E2E Testing & Proof-of-Work

Skill Slash Command Description What It Accomplishes
e2e-driven-dev /e2e-driven-dev, /do-e2e-driven-dev Text-narrated E2E driven development Executes feature development verified by automated end-to-end testing with audio narration and video capture.
record-demo /record-demo <Script> Record 1080p narrated video walkthrough Uses headless Xvfb, FFmpeg, and neural TTS (Piper) to record high-definition video walkthroughs with WebVTT captions, archived to ~/.robos/development/walkthroughs/.
test-container /test-container Run headless containerized E2E tests Launches isolated containerized E2E test suites inside Docker with Xvfb virtual framebuffers and Picom compositors.
app-snapshot /app-snapshot <App> Capture DOM text/JSON/screenshot snapshots Connects to running Electron applications via snapshot debug ports (19100–19121) to capture live UI states and DOM trees.

4. VM & Operating System Control

Skill Slash Command Description What It Accomplishes
build-vm /build-vm Build QEMU VM disk image & cloud-init ISO Creates sparse qcow2 virtual disks and stateless cloud-init ISOs for Ubuntu 26.04 LTS RobOS desktop.
start-vm / stop-vm /start-vm, /stop-vm Start or stop the RobOS virtual machine Launches QEMU with hardware KVM acceleration, GTK/VNC displays, and forwarded SSH ports (2224).
vm-status /vm-status Inspect running VM state and diagnostics Queries SSH connectivity, memory usage, and hypervisor process state.
vm-ssh /vm-ssh "<Command>" Execute shell commands inside the VM Executes remote administrative commands inside the virtual machine with non-interactive authentication.
deploy-to-vm /deploy-to-vm <Package> Deploy packages directly to the running VM Transfers code via SCP to /usr/local/share/robos/, fixes permissions (chmod -R a+rX), and rebuilds node modules.
add-install-step /add-install-step Add cloud-init provisioning step Extends first-boot automated provisioning and updates the terminal splash screen.
restart-taskbar /restart-taskbar Restart desktop dock and manager Sends IPC signals to /run/user/<uid>/robos-dm.sock to reload the GNOME desktop taskbar without terminating active applications.

5. System Diagnostics & Marketplace Management

Skill Slash Command Description What It Accomplishes
install-dev-deps /install-dev-deps Audit and install host dev dependencies Audits and installs host packages: QEMU, KVM, Node.js, Electron, JDK 17+, and Piper TTS.
read-error-logs /read-error-logs Inspect centralized RobOS error stream Queries centralized JSON error logs and Electron crash dumps for rapid root-cause analysis.
report-issue /report-issue Convert bug reports into structured issue specs Structures user reports into markdown issue files in docs/issues/reported/ with reproduction steps and logs.
manage-robos-skill /manage-robos-skill Add, update, or remove marketplace skills Scaffolds new skills, manages manifests, and synchronizes across all agent platforms.

Universal Cross-Agent Installation & Sync

RobOS skills adhere to an agent-agnostic format that allows any modern AI coding assistant to discover and execute them immediately.

One-Click Synchronization

Whenever you add, modify, or update a skill in plugins/robos/skills/, run:

./plugins/install.sh --sync

This automatically synchronizes manifests and command bridges across:

  • Claude Code: .claude/commands/<skill-name>.md
  • OpenAI Codex: .agents/skills/<skill-name>/SKILL.md and AGENTS.md
  • Google Antigravity: .antigravity/commands/<skill-name>.md and .agents/skills/
  • GitHub Copilot: .github/skills/<skill-name>/SKILL.md
  • Gemini CLI: .gemini/commands/<skill-name>.md

Installing Globally

To make RobOS skills available across all workspaces on your development machine:

./plugins/install.sh --global

Anatomy of a RobOS Skill (SKILL.md)

Every RobOS skill is defined in a standard directory structure:

plugins/robos/skills/<skill-name>/
├── SKILL.md                 # Primary instruction document with YAML frontmatter
└── scripts/                 # Optional companion CLI scripts and automation engines
    └── <skill-name>.js

Example: Standard SKILL.md Format 

---
name: import-company-kgraph
description: Import company, organization, or team Knowledge Graph entries from any source (HTTP, FileSystem, S3, or Git) and generate validated OSLC JSON-LD files.
---

# Import Company Knowledge Graph

<Overview of what the skill accomplishes>

## When to Use
<Scenarios and triggers when an agent should execute this skill>

## Input
$ARGUMENTS — Parameter flags:
- `--source <path|url|s3-uri>`: Ingestion endpoint
- `--company-name <name>`: Organization title
- `--import-to-robos`: Merge directly into workspace

## Procedure
1. Parse and validate source input.
2. Execute companion script: `node scripts/import-company-kgraph.js $ARGUMENTS`.
3. Verify generated JSON-LD output files.

## Validation Checklist
- [ ] Output conforms to OSLC JSON-LD and C4 schema.
- [ ] No plaintext credentials stored in graph files.

Authoring New Skills with /manage-robos-skill

RobOS provides the manage-robos-skill skill to automate creating and registering new skills:

# Scaffold and register a new skill in one command:
/manage-robos-skill add inspect-k8s-logs "Stream and analyze Kubernetes pod logs for microservice crashes"

This automatically:

  1. Validates the lowercase kebab-case naming convention.
  2. Scaffolds plugins/robos/skills/inspect-k8s-logs/SKILL.md.
  3. Generates the command bridge plugins/robos/commands/inspect-k8s-logs.md.
  4. Registers the skill in plugins/robos/plugin.json.
  5. Syncs across all agent platforms via ./plugins/install.sh --sync.

The Skills Manager Desktop App (packages/skills-manager)

In addition to AI agent skills, RobOS includes the Skills Manager application (packages/skills-manager), which equips developers with an interactive GUI library of 74+ shell and system diagnostic commands:

  • 10 Categorized Packs: File Operations, Process Management, Git Operations, Networking, Docker / Containers, System Info, Package Management, Text Processing, Security, and Development Runtimes.
  • Instant Search & Parameterization: Search by tag, keyword, or command name, with customizable argument fields.
  • Custom Skill Creation: Add personal terminal macros and scripts stored in ~/.config/robos/skills.json.
  • Integration with <robos-ai-textarea>: Every skill in the manager is available via @-mention typeahead in AI prompt boxes throughout RobOS applications.

To launch the Skills Manager, open Skills Manager from the RobOS App Launcher (searchable application grid in the panel/dock), or launch it from the terminal:

electron packages/skills-manager

The Future: Standardized Turing Skills & Compiled Machine Code

While RobOS skills today exist as vendor-agnostic markdown specifications (SKILL.md) and shell commands, RobOS is engineered towards an ultimate destination: Turing machine-inspired skill structures whose leaf capabilities are compiled down to native machine code (.so, .dylib, ELF, or WebAssembly AOT).

In this future architecture:

  • Every atomic capability is formally modeled with strict input and output tapes.
  • Leaf skills are compiled to raw binaries and invoked like C-ABI method calls with zero LLM overhead.
  • Consumer hardware running local models (Ollama, llama.cpp) can assemble and link these compiled skills into complete, working applications—entirely offline, without data center reliance.

Read the complete vision in The Future of Software Development: Turing Skills, Compiled Machine Code & Local Edge Assembly.

Verification & Automated Testing

All skills are verified using automated tests in the packages/robos-test framework:

# Test the company KGraph import skill:
node --test packages/robos-test/tests/skills/import-company-kgraph.test.js

# Test the Skills Manager desktop app:
node --test packages/robos-test/tests/skills-manager/smoke.test.js

# Run the narrated Skills Manager walkthrough demo:
node packages/robos-test/demos/skills-manager-demo.js

Next Steps

Table of contents