Skip to content

Update README.md #385

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
mrubens merged 1 commit into from
Jul 15, 2026
Merged

Update README.md #385

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
300 changes: 215 additions & 85 deletions README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,126 +1,256 @@
# Roomote

Roomote is the flexible, self-hostable cloud coding agent that works alongside
your team. It's not an IDE or a local copilot: it's a full stack application,
exposed as a shared, always-on agent to which your team can assign work and get
back pre-reviewed, verified pull requests.
**A cloud coding agent you deploy in minutes and actually own.**

You give it a task in Slack (or Teams, or Telegram). It clones your repo into an
isolated sandbox, writes the code, runs the tests, takes a screenshot, and opens
a PR. You review the diff like you would from any teammate.

No IDE plugin. No terminal session. No babysitting. It works while you do
something else.

```
"Fix the 500 on /api/billing for annual plans"

→ Roomote picks up the task
→ spins up a sandbox with your full repo
→ finds the bug, writes a fix, runs the test suite
→ opens a PR with a screenshot of the working page
→ you review, merge, done
```

Source-available. Self-hostable. Bring your own API keys.

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/Rj2cFo)
  
[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/RooCodeInc/Roomote)

![Roomote chat workflow demo](assets/roomote-hero.gif)

It's an open, self-hostable platform that helps teams move agentic coding work:
---

- From single-player to multiplayer
- From synchronous to asynchronous
- From reactive to proactive
- From closed to open
## How it works (60-second mental model)

It does it by running agents in ephemeral, isolated sandboxes, where they make
changes, verify their work, and create PRs. Roomote can answer questions, take
screenshots of its changes, and read/write to your services (logs, monitoring,
databases, etc).
Roomote is a full-stack application, not an extension or a wrapper. It connects
to the tools you already use and runs agents in throwaway sandboxes.

Roomote prizes flexibility while optimizing for user experience:
```
┌──────────────────────────────────────────────────────────────┐
│ You (in Slack / Teams / Telegram / Web UI) │
│ "Add dark mode to the settings page" │
└──────────────┬───────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────┐
│ Roomote │
│ │
│ ┌────────────┐ ┌───────────────┐ ┌──────────────────┐ │
│ │ Your models │ │ Your repo │ │ Your tools │ │
│ │ (BYOK) │ │ (GitHub, │ │ (Linear, Sentry, │ │
│ │ Claude, │ │ GitLab, │ │ Notion, Jira, │ │
│ │ GPT, etc. │ │ Gitea, │ │ Grafana, PH, │ │
│ │ │ │ Azure DevOps) │ │ Figma, etc.) │ │
│ └──────┬─────┘ └───────┬───────┘ └────────┬─────────┘ │
│ │ │ │ │
│ └────────┬────────┘─────────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Ephemeral sandbox (Modal, E2B, Daytona, or Docker) │ │
│ │ │ │
│ │ clone repo → make changes → run tests → screenshot │ │
│ │ → push branch → open PR │ │
│ └──────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────┘
│
▼
Pull request with diff, screenshots, and a live preview URL
```

- Quick setup and a consumer-grade web UI
- Model-agnostic inference provider setup with bring-your-own-key support
- Source control via GitHub, GitLab, Gitea, and Azure DevOps
- Agent interactions via Slack, Microsoft Teams, Telegram, and the web
- Sandbox compute via Modal, E2B, Daytona, and Docker
- Self-configuring agent development environments
- Live web previews of agent changes from sandboxes
- Dozens of tool integrations (task management, logs, monitoring, documents, etc)
Every task gets its own sandbox. Nothing touches your local machine. The agent
cleans up after itself.

## Requirements
---

- A model provider API key, such as OpenRouter, Anthropic, OpenAI, etc
- A source-control service, such as GitHub, GitLab, Gitea, or Azure DevOps
- A communications provider, such as Slack, Microsoft Teams, or Telegram
(optional but strongly recommended)
- Somewhere to run it: a single Ubuntu/Debian host, Railway, Coolify, Fly.io,
etc
## Five-minute quickstart

For live sandbox previews and production deployments, you'll need DNS
configuration access.
Pick one path. You will have a working Roomote instance at the end.

## Quick Start
### Option A: One-click deploy (Railway)

_We're interested in PRs for tested support for other PaaS providers._
1. Click the button:

### Railway
[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/Rj2cFo)

Railway uses managed Postgres/Redis and hosted sandboxes such as Modal, E2B, or
Daytona. Docker sandboxes are not available there. The template below tracks the
stable `main` channel; a develop-channel template also exists — see
[deploy/railway/README.md](deploy/railway/README.md).
2. Railway provisions Postgres, Redis, and the app. Follow the prompts to set
your admin email and password.

[![Deploy with the template](https://railway.com/button.svg)](https://railway.com/deploy/Rj2cFo)
3. Open the setup link Railway gives you. Connect a model provider (paste an API
key from Anthropic, OpenAI, OpenRouter, or others).

### Coolify
4. Connect GitHub (or GitLab, Gitea, Azure DevOps).

Deploy the stack as a Docker Compose resource from the maintained
template. Coolify runs on your own server and defaults to Docker sandboxes on
that host; see [deploy/coolify/README.md](deploy/coolify/README.md).
5. Open Slack, send Roomote a message:

### Render
```
What files are in the root of the repo?
```

Render deploys the maintained Blueprint ([render.yaml](render.yaml)) with
managed Postgres and Key Value (Redis) plus hosted sandboxes such as Modal,
E2B, or Daytona. Docker sandboxes are not available there. The deploy button
below tracks the stable `main` image channel; see
[deploy/render/README.md](deploy/render/README.md).
**Expected output:** Roomote lists your repo's top-level files and asks what
you'd like to work on.

[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/RooCodeInc/Roomote)
You now have a working cloud coding agent. Total time: ~3 minutes.

### Fly.io
### Option B: One-click deploy (Render)

Run the stack as a single Fly app (one Machine per service) with Fly Managed
Postgres, Upstash Redis, and Tigris object storage from the maintained
`fly.toml`. Docker sandboxes are not available there, so task execution uses
hosted sandboxes such as Modal, E2B, or Daytona. The maintained config tracks
the stable `main` image channel. Fly has no one-click template marketplace, so
deploys are a short copy-paste `flyctl` sequence; see
[deploy/fly/README.md](deploy/fly/README.md).
1. Click the button:

### Bare machine
[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/RooCodeInc/Roomote)

SSH into a fresh Ubuntu or Debian server (x86_64 or arm64) with at least 4 GB RAM
recommended and run the installer as root:
2. Render creates managed Postgres, Redis, and the app. Set your admin
credentials when prompted.

3. Open the setup link, connect a model provider and source control.

4. Send Roomote a test message in Slack. Same expected output as above.

### Option C: Self-host on your own server

SSH into a fresh Ubuntu/Debian machine (4 GB RAM recommended) and run:

```sh
curl -fsSL https://get.roomote.dev | bash
```

If your SSH user is not root, run it through `sudo bash`:
The installer handles Docker, secrets, and the Compose stack. It prints a setup
link when it finishes. Connect your model provider and repo, then send a test
message.

```sh
curl -fsSL https://get.roomote.dev | sudo bash
```
For production, point DNS at your server and pass `--domain roomote.example.com`.

See also: [Coolify](deploy/coolify/README.md) and [Fly.io](deploy/fly/README.md)
deployment guides.

---

## What can it do?

Roomote handles the work that pulls you off your main project:

- **Fix bugs.** Paste an error, a Sentry link, or a stack trace. It reads the
code, reproduces the issue in its sandbox, writes a fix, and opens a PR.
- **Answer codebase questions.** "How does auth work?" or "Where is the
billing logic?" It reads the code and gives you a real answer.
- **Handle chores.** Dependency upgrades, linter fixes, config changes,
migration files, boilerplate.
- **Build small features.** "Add a dark mode toggle to settings." It writes the
code, runs the app, takes a screenshot, and opens a PR with a preview link.
- **Triage issues.** Connect Linear, Jira, or GitHub Issues. It reads new
tickets, asks clarifying questions, and starts working.

It connects to dozens of tools (Sentry, Grafana, PostHog, Notion, Figma, and
more) so it can read logs, check dashboards, and pull context without you
copy-pasting.

The installer installs Docker when needed, generates deployment secrets, starts
the production Compose stack from GHCR images, and prints a setup link. By
default it uses an `sslip.io` hostname derived from the server IP, so no DNS is
needed for a trial. For production, pass `--domain roomote.example.com` after
pointing the app, preview, and wildcard preview DNS records at the host.
---

Interested in a Roomote-managed deployment? [Ping us](mailto:help@roomote.dev).
## Why self-host a coding agent?

Read more on [Self-hosting](https://docs.roomote.dev/self-hosting) in the docs.
- **Your code stays on your infrastructure.** No repo access leaves your
network.
- **Bring your own keys.** Use Anthropic, OpenAI, OpenRouter, or any provider.
Switch models per task. No markup on tokens.
- **Read every line.** The full source is here. Audit it, extend it, fork it.
- **No per-seat SaaS pricing.** Free for up to 10 users. Need more? Get a
license key.

---

## Teams and organizations

Roomote is multiplayer by default. When someone assigns a task, the whole team
sees the progress and the resulting PR.

Features that matter at scale:

- **Parallel agents.** Run multiple tasks at the same time across different
repos.
- **Shared context.** Agents learn your codebase conventions, test patterns,
and deploy process.
- **Audit trail.** Every action is logged: which model was used, what tools
were called, what code was written.
- **Web UI.** Consumer-grade dashboard for managing tasks, reviewing output,
and configuring integrations.
- **Live previews.** Agents spin up a preview URL so reviewers can click
through changes before merging.

### Enterprise

Need SSO, custom SLAs, or dedicated support? Email
[help@roomote.dev](mailto:help@roomote.dev).

Want a managed deployment instead of self-hosting? We can run it for you.
[Get in touch](mailto:help@roomote.dev).

---

## FAQ

**Is Roomote open source?**
It is source-available under the [Fair Core License 1.0](LICENSE) (FCL-1.0-ALv2).
You can read, modify, and self-host the code. Free for up to 10 users. Larger
deployments need a license key. After the license period, the code converts to
Apache 2.0.

**How is this different from Cursor / Copilot / Claude Code?**
Those are IDE tools that help you write code faster in your editor. Roomote is a
standalone agent: you assign it a task, walk away, and come back to a PR. It
does not require an IDE or a terminal session.

**How is this different from Devin?**
Devin is a closed, hosted product. Roomote is source-available and
self-hostable. You own your data, bring your own API keys, and pick your models.
You can read every line of code it runs.

**What models does it support?**
Any model accessible through Anthropic, OpenAI, OpenRouter, AWS Bedrock, Google
Vertex, Azure OpenAI, or a compatible API. You bring your own keys.

**What repos can it access?**
GitHub, GitLab, Gitea, and Azure DevOps. Connect one or many.

**What does it cost?**
Self-hosting is free for up to 10 registered users. You pay your own model
provider for tokens. For larger teams, license keys are available at
[roomote.dev](https://roomote.dev).

**Can non-engineers use it?**
Yes. PMs, support, ops, and marketers can assign tasks in Slack without touching
code. "Fix the typo on the pricing page" works.

---

## Documentation

- [Public docs](https://docs.roomote.dev) for admins and users
- [Local development](LOCAL_DEVELOPMENT.md) for contributors
- [Public docs](https://docs.roomote.dev): setup, configuration, integrations
- [Self-hosting guide](SELF_HOSTING.md): DNS, production config, scaling
- [Local development](LOCAL_DEVELOPMENT.md): contributing to Roomote itself

## Community

- [Discord](https://discord.gg/roomote): questions, showcase, feature requests
- [GitHub Issues](https://github.com/RooCodeInc/Roomote/issues): bug reports
and feature requests

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md) and the [CLA](CLA.md).

## Security

## License, Security, And Contributions
Report vulnerabilities privately. See [SECURITY.md](SECURITY.md).

Roomote is licensed under the Fair Core License 1.0 with an Apache-2.0
future grant (FCL-1.0-ALv2). See [LICENSE](LICENSE). A deployment is free
for up to 10 registered users — every user account counts toward the
limit; larger deployments require a paid license key entered in
Settings → Users. Per the license terms, the license key functionality may
not be disabled or circumvented. Need a license? Email [help@roomote.dev](mailto:help@roomote.dev)
## License

Security reports should be sent privately. See [SECURITY.md](SECURITY.md).
Contribution expectations and the Contributor License Agreement requirement are
in [CONTRIBUTING.md](CONTRIBUTING.md); the agreement itself is in [CLA.md](CLA.md).
Trademark guidance is in [TRADEMARKS.md](TRADEMARKS.md).
[Fair Core License 1.0 (FCL-1.0-ALv2)](LICENSE). Free for up to 10 users.
The license key functionality may not be disabled or circumvented.
[TRADEMARKS.md](TRADEMARKS.md) covers trademark usage.
Loading