Rome

The agentic OS for humans and agents.

Website · Try Rome Cloud · Documentation · App Store

What is Rome?

Most progress in AI comes from scaling models. Rome scales the other axis, the environment: the tools, workflows, memory, and interfaces an agent works within (why this matters).

Rome is a guardrailed environment where human and agent collaborate, and the collaboration compounds. Agents build their own harnesses, design their own SOPs, and orchestrate workflows under your guidance. Proven capabilities stick. Every interaction raises the ceiling for the next.

Get started

Rome Cloud

Rome Cloud provisions a private Rome environment for each guardian. It is currently
available as a preview.

Join the preview →

Run with Docker

One script checks for Docker, pulls the published image, and starts Rome:

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

Or clone the repository and run the script from it:

git clone https://github.com/rome-os/rome.git
cd rome
./scripts/quickstart-docker.sh

The dashboard comes up at http://localhost:7663, bound to loopback only —
first-run onboarding is open to whoever reaches it first, so exposing it
beyond the machine takes an explicit --bind. State lives in named Docker
volumes, so re-running the script upgrades the container without losing data.
Telemetry export stays off unless you set OTEL_EXPORTER_OTLP_ENDPOINT. Run
the script with --help for ports, profiles, and the other settings it
forwards.

Run the development environment

To run this repository from source, you need:

• Node.js 24 or newer
• Corepack and pnpm 11.6
• Docker with Docker Compose

From a checkout of this repository:

corepack enable
pnpm install
pnpm dev:all

pnpm dev:all starts the production-shaped local stack: Rome, observability,
routing, and the web development server. It connects to https://romeos.cc by
default; set ROME_DEV_PANTHEON_ORIGIN to use another Rome Cloud deployment.
The script prints the local URLs and development credentials when startup completes.

This is the contributor development path, not the final production self-hosting
distribution. See CLAUDE.md for the complete development loop,
container commands, and validation requirements.

Rome Apps

Rome App is the new way to interact with your agent.

Chat is a good place to ask for something once. Repeated work deserves a place of
its own: an inbox that remembers what was triaged, a code review loop you can
inspect, a price tracker that keeps watching, or a morning brief that arrives on
schedule.

A Rome App combines a purpose-built interface, agent reasoning, reusable
workflows, and persistent data into one installable product. It is not a thin
wrapper around a prompt. The app remains useful after the conversation ends,
after the browser closes, and when the user comes back tomorrow.

A useful rule of thumb: a workflow is a verb; an app is a noun. Use a
workflow to perform a task and return a result. Build an app when the work needs
a home of its own—with user-editable data, multiple actions, or a persistent
agent.

Rome can build the missing app

When there is not an app for what you need, describe it to Rome in plain
language. Rome can turn that request into a short specification, scaffold the
app or workflow, build it into your instance, and keep iterating with you in the
same conversation.

The result is ordinary, git-tracked source code rather than hidden model state.
Keep it private, adapt it as your needs change, or publish it for others to
install from the App Store. This creates Rome's self-evolution loop:

Describe a need → Rome builds the capability → the app keeps working
       ↑                                              ↓
       └──────────── refine, reuse, and share ────────┘

Under the hood

A Rome App starts with an app.yaml manifest and can ship any mix of:

Together these form a capability: the unit Rome discovers and reuses in
later work. The app is that capability's human interface: apps organize human
interaction; capabilities organize agent action.

Apps build on two public SDKs:

• @rome-os/app-runtime for backend capabilities.
• @rome-os/app-web-sdk for embedded web interfaces and the Rome build CLI.

Browse the Rome App Store, read the
building guide, or start with the
app quickstart.

What people do with Rome

These are the kinds of requests Rome is designed to follow through on:

Rome can handle one-off tasks, scheduled work, long-running follow-through, and
purpose-built app experiences without forcing everything into one chat window.

Repository map

Rome is a pnpm monorepo.

Common checks:

pnpm typecheck
pnpm test:unit
pnpm lint
pnpm build

Documentation

• VISION.md — why Rome exists and the product principles it protects.
• docs/concepts/ — canonical domain vocabulary.
• docs/architecture/ — component boundaries and
  system invariants.
• Using Rome — public guardian documentation.
• Building Rome Apps — public app-author
  documentation and SDK guides.

Give your agents a place to grow.
Start with one workflow. Rome keeps what works and compounds from there.