rome-os/rome

Rome is an open-source (MIT) platform for what it calls recursive agents — AI agents that work alongside you, keep improving, and build their own tools as they go. The tagline is "a compounding agent OS": every interaction raises the ceiling for the next one.

The big idea

Instead of only scaling up AI models (bigger brains), Rome scales up the environment the agent works in — the tools, workflows, memory, and interfaces. Under your guidance, agents build their own harnesses, design their own standard procedures, and orchestrate workflows. What works sticks: proven capabilities are kept and reused, so each request can ask for more than the last.

Rome Apps — the main way you interact

Chat is fine for one-off requests, but repeated work deserves its own home. A Rome App combines four things into one installable product:

• Purpose-built UI — an interface designed for the job (not a chat box)
• AI-native — agents are part of how the product works
• Persistent by default — data and workflows carry forward between sessions
• Community-powered — you can install, share, and learn from other builders

A rule of thumb from the README: a workflow is a verb; an app is a noun. A workflow performs a task and returns a result. An app is a place where recurring work lives — an inbox for triaging email, a code-review loop, a price tracker, a scheduled morning brief.

Rome can build the missing app. Describe what you need in plain language, and Rome turns it into a spec, scaffolds the app, and iterates with you — producing ordinary git-tracked source code, not hidden model state. You can keep it private, adapt it, or publish it to the App Store.

Each app can ship a mix of artifacts: actions (typed operations agents can call), agents (app-owned collaborators), skills (plain-language procedures), hooks (lifecycle extensions), web UI/APIs, and database/files. Together these form a capability — the reusable unit Rome discovers in later work.

Example uses

• "Fix all P1 and P2 review comments until there are no merge blockers left."
• "Sort my inbox. Archive the noise, flag anything urgent, draft replies."
• "Track this game's price and tell me when it drops below $30."
• "Interview five customers about onboarding and summarize what to improve."

Rome handles one-off tasks, scheduled work, long-running follow-through, and purpose-built apps — not just chat.

How to run it

Rome Cloud — a hosted preview; join at romeos.cc/login.

Docker (simplest) — one script checks Docker, pulls the image, and starts Rome:

curl -fsSL https://raw.githubusercontent.com/rome-os/rome/main/scripts/quickstart-docker.sh | bash

The dashboard appears at http://localhost:7663 (loopback only). State lives in named Docker volumes, so re-running upgrades without losing data. Telemetry stays off unless you set an endpoint explicitly.

Development (from source) — needs Node.js 24+, Corepack/pnpm 11.6, and Docker Compose:

corepack enable
pnpm install
pnpm dev:all

Under the hood

It's a pnpm monorepo:

• packages/core/ — agent runtime, sessions, actions, events, channels, policies, memory
• packages/web/ — guardian-only web dashboard
• packages/desktop/ — Electron shell and local runtime
• rome_apps/ — first-party Rome Apps
• Two public SDKs: @rome-os/app-runtime (backend) and @rome-os/app-web-sdk (web UI + build CLI)

Why it's different from similar tools

The README compares Rome to products like Grok Bot (xAI), Muse (Meta), Hermes Agent, Manus, and Wabi. The key distinction: what compounds. Others compound hosted bot state, notes, files, or a network of shareable apps. Rome compounds the environment — executable, composable capability that you own, is git-tracked, and survives a model swap. Because everything is open and exportable, you're not locked in.

Getting involved

Docs live at romeos.cc/docs. There's a website, Discord, and an X account (@RomeAILab). The closing tagline: "Give your agents a place to grow. Start with one workflow. Rome keeps what works and compounds from there."