What is it?
What it is
Rome is an agentic OS for humans and agents—a guardrailed environment where human and agent collaboration compounds. It provides tools, workflows, memory, and interfaces for agents to work within, enabling proven capabilities to accumulate over time.
Why it exists
To scale beyond just model scaling by providing rich environments where agents can build their own harnesses, design SOPs, and orchestrate workflows under guided collaboration. Rome complements traditional AI progress by focusing on the environment layer.
Who should use it
Developers and engineers building AI-powered applications with persistent agents, teams implementing multi-agent systems, technical users who want to create custom Rome Apps with typed actions, agents, skills, and hooks, researchers working with agentic AI frameworks, and organizations looking for a guardrailed environment where human and AI agents can collaborate on complex workflows with persistent memory and state.
Who should avoid it
Non-technical users without programming experience, those seeking a simple chatbot or single-prompt LLM interface, users who want a lightweight solution without Docker dependencies, people looking for a no-code platform, and anyone unwilling to work with TypeScript and command-line tools.
How it works
A quick walkthrough in plain English
How rome works in 4 steps
Step 1 of 4
Something triggers the flow
A schedule, webhook, or manual click tells rome to start.
Features
Advantages
- MIT-licensed and TypeScript-based, making it accessible for community contribution and modification
- Separates capabilities (agent actions) from apps (human interfaces), enabling reuse across workflows
- Apps are ordinary git-tracked code rather than hidden model state, simplifying versioning and auditing
- Docker quickstart with loopback-only binding and opt-in telemetry improves local security posture
- Persistent by default design means workflows and data survive across sessions and browser closures
- Multi-interface access via web dashboard, Electron desktop shell, and cloud-hosted deployment
- Active community channels (Discord, X/Twitter) and dedicated documentation for both guardians and app authors
- Production-shaped local development stack via pnpm dev:all for realistic testing
- 387 GitHub stars indicate growing interest and a budding ecosystem
Disadvantages
- Rome Cloud is only available as a preview, limiting immediate production cloud usage
- Requires Node.js 24+ and pnpm 11.6, which is stricter than typical baseline toolchain requirements
- Local development stack is explicitly marked as not the final self-hosting distribution, creating ambiguity for self-hosters
- First-run onboarding dashboard is open to whoever reaches it first on the bound port, which could be a footgun in shared networks
- Star count of 387 suggests a relatively early-stage project with a smaller community than more mature alternatives
- Default local development configuration connects to romeos.cc, introducing external dependency during local work
- Complexity of the app model (Actions, Agents, Skills, Hooks, Web UI, APIs, Database) presents a steep learning curve for new builders
Installation
cloud
Rome Cloud provisions a private Rome environment for each guardian. It is currently available as a preview. Join the preview at https://romeos.cc/login to get started.
docker
One script checks for Docker, pulls the published image, and starts Rome. Run via: curl -fsSL https://raw.githubusercontent.com/rome-os/rome/main/scripts/quickstart-docker.sh | bash. Or clone and run: git clone https://github.com/rome-os/rome.git && cd rome && ./scripts/quickstart-docker.sh. Dashboard at http://localhost:7663, loopback only. Expose beyond machine with --bind. State in named Docker volumes; re-running upgrades without data loss. Set OTEL_EXPORTER_OTLP_ENDPOINT for telemetry.
native
To run from source: Node.js 24 or newer, Corepack and pnpm 11.6, Docker with Docker Compose. Enable corepack with corepack enable, then pnpm install, then pnpm dev:all. This is the contributor development path, not the final production self-hosting distribution.
compose
Development environment requires Docker with Docker Compose. Run pnpm dev:all to start the production-shaped local stack (Rome, observability, routing, web dev server). Connects to https://romeos.cc by default; set ROME_DEV_PANTHEON_ORIGIN for alternative deployments.
FAQ
How do I start Rome locally with Docker?
Run the quickstart-docker.sh script (via curl or by cloning the repo) which checks for Docker, pulls the published image, and starts the container. The dashboard becomes available at http://localhost:7663 (loopback only). Use the --bind flag to expose it beyond the machine.
What are the prerequisites to run the development environment from source?
You need Node.js 24 or newer, Corepack, pnpm 11.6, and Docker with Docker Compose. After cloning the repo, enable Corepack, run pnpm install, and execute pnpm dev:all to launch the full local stack.
How can I expose the local dashboard beyond localhost?
The dashboard is bound to loopback only by default. Start the quickstart script with the --bind option (or set the appropriate environment variable) so the container listens on a public interface, allowing remote access.
What is the difference between a workflow and an app, and how do I create a new app?
A workflow is a verb — a task that returns a result — while an app is a noun — a persistent, installable product with its own UI and data. To create an app, describe your need to Rome, let it generate an app.yaml manifest and scaffold the code using the @rome-os/app-runtime and @rome-os/app-web-sdk, then keep the source under git for editing and sharing.
Where can I find the public documentation and the App Store?
All public documentation is hosted at https://romeos.cc/docs (including concepts, architecture, and usage guides). The Rome App Store is reachable at https://romeos.cc/store, where you can browse and install community‑built apps.
Featured in Videos
YouTube tutorials and walkthroughs for rome
Alternatives
Similar projects ranked by category, topics, and text overlap.
