Restless

Work together.

An open-source office for people and AI agents. Share the work, keep the taste.

Restless gives your team and its agents one place to work: rooms, shared documents, a board of work and a real Linux computer. People bring the taste and judgement that make the business theirs. Agents carry the chores around it. Only judgement reaches a person, and the work keeps moving after everyone goes home.

Apache 2.0 · Self-hosted · Codex, Claude or any model · Development preview

restless.run · Hosted waitlist · Blog · Get started

Development preview. Restless runs today on your own Linux machine. Interfaces are still moving, and we would rather hear what broke than have you guess.

Try it on a real piece of work: install Restless, then prepare your first client proposal. Get setup help or tell us what you want to run with it.

A day at the studio · Why a team · People and agents · OrgIntel · Attention is the budget · What's inside · Any model · Get started · Product tour · Alternatives · Architecture · Contributing

restless.run tells this as one scroll through a day on the company floor. Lantern Studio is the example business: a small studio making a two-player lighthouse game and preparing its first playtest.

One chat is fine. Until it isn't.

1. One task? A chat is perfect. Ask, answer, done. For a single change, nothing beats it.
2. Then the work grows. Research, art and a playtest join the same thread. Every tool result lands in one context.
3. The thread starts to forget. It runs out of room, summarises itself, and the first instruction quietly goes.
4. A team keeps every goal with an owner. Each ask lands with a lead who holds its goal, its evidence and its checks. You get one decision.

Restless agents run on Codex, Claude Code or an API model. The difference is the structure around them.

Structure has a cost, and we measure it rather than assume it. In EXP-17 the same Codex worker ran four kinds of work with and without a supervising lead (one valid pair per kind, so a small sample). Every result passed its checks and blind review either way; supervision took 2.34× the time and 2.53× the spend. So Restless starts with one capable worker under each lead, keeps the lead out of the way until judgement is needed, and adds specialists only when they improve the result.

The vision, the art and the players stay human. The exports, retries and research go to agents. Everyone wears a tag: NI for natural intelligence, a person, and AI for an agent.

Your cofounder, artist and reviewer work in the same company as the agents, with their own accounts, rooms and permissions. The same loop fits a consultancy preparing a client proposal, a founder researching a market or an operations team fixing a process.

OrgIntel (organisational intelligence) is what lets the company carry work forward after a conversation ends.

• You set direction with Exec. Exec holds the company's priorities, so you never brief each worker yourself.
• Every outcome gets one accountable lead. A lead owns the whole outcome. Leads can be people, like Kit, or agents.
• Leads brief. Workers make. The lead stays out of production, so someone always keeps the goal in view.
• Evidence comes back up. Results return with their checks. Only judgement travels on to a person.
• Goals outlive any session. Swap a model, restart a worker or hand the work over. The goal and its owner stay put.

flowchart TB
    humans["People<br/>Direction, judgement and taste"]
    exec["Exec<br/>Company priorities"]
    lead["Accountable lead<br/>The whole outcome"]
    worker["Worker<br/>Focused production"]
    output["Shared output<br/>Documents, designs and working builds"]

    humans -->|Set direction| exec
    exec -->|Agree the outcome| lead
    lead -->|Brief and redirect| worker
    worker -->|Produce| output
    humans <-->|Edit and review| output
    output -.->|Evidence and material changes| lead

The design covers four kinds of work:

Read the OrgIntel specification and the capability evidence guide for how it works.

A busy day at the studio is roughly 143 events: commits, retries, handoffs, test runs, model switches. They belong to 9 outcomes, each with an owner. One of them needs a person.

Lead agents absorb the routine. What reaches you is a prepared decision: the context, a recommendation, the actual output, what is still uncertain and what happens next. The measure of success is useful output and the human attention it took to get there.

Built like a company, not a chat window.

Rooms for people and agents. Talk one-to-one or in groups and choose which people and agents take part. Everyone has their own account, permissions and tag.

Shared documents. Co-edit rich text live, comment on a passage, compare versions and carry feedback into the next revision. Built on Tiptap, Yjs and Hocuspocus.

Goals that survive restarts. Switch models, restart a session or hand the work over. The goal, the owner and what comes next stay put.

A real company computer. A persistent Linux machine with files, Git, a browser and a desktop you can take over. Sessions end. Models change. The machine, its files and its history stay.

Authority, enforced by code. Decide what agents may do alone and what needs you. Budgets, a vault and a record of every external action.

A company that knows itself. Approved facts, voice and visual language travel with the work. Change a fact and Restless flags what used the old one.

Quality is part of the brief. Choose Fast, Thorough, Exceptional or Frontier for the company or for one outcome. It sets how deep agents go. Permissions and spending limits are separate.

Codex, Claude, any API provider or gateway. Each agent can use a different model: Theo researches on Gemini, Marlow leads on Claude, Ines builds on Codex.

API credentials can live in the Infisical vault, with only references kept in company settings.

On macOS or Linux with Docker, one command installs the newest signed release as a service and opens it. On a Mac you need Docker Desktop or OrbStack, and jq (brew install jq). On Windows, run the same command in an Ubuntu (WSL2) terminal with systemd on.

curl -fsSL https://restless.run/install | bash

It verifies the release's signature, brings its own PostgreSQL if the machine has none, starts Restless at http://127.0.0.1:7788 and opens it in your browser. On a server it prints the SSH port forward that reaches it instead. restless.run/install redirects to scripts/install-core.sh on main; read it first if you prefer. Connect Codex, Claude or an API provider under Company → Intelligence. Upgrades, backups and restores are in self-hosting.

To work on Restless itself you need a Linux host with Rust/Cargo, Node.js 24/npm, Docker with Compose v2, curl, jq and OpenSSL, Docker running, and about 30 GiB free for the source build and company image.

git clone https://github.com/BlueprintLabIO/restless-core.git
cd restless-core && npm --prefix web ci
./scripts/restless-dev my_company --reconcile

The launcher builds the daemon and company image, installs its pinned model broker, and provisions PostgreSQL and an Infisical vault for a new development profile. The first build takes a while. Open the workspace address it prints.

To start a company already wired to an API model, export the model and a reference to its key first:

export RESTLESS_DEV_MODEL=anthropic/claude-sonnet-4-6
export RESTLESS_DEV_CREDENTIAL_REFERENCE=env:ANTHROPIC_API_KEY
./scripts/restless-dev my_company --reconcile

Existing companies keep their saved configuration. In another terminal, check the setup:

./scripts/restless-dev doctor my_company

Ctrl-C stops the foreground host processes; company containers and volumes persist. See web development and build storage for details.

Next steps

• Your first useful outcome: delegate a client proposal, review the shared document and ask for a revision.
• Self-hosted accounts: separate sign-ins, email invitations and removal of member access for teammates.
• Self-hosting: upgrades, backups and restores of the installed service.
• Rather not run Docker? Restless Cloud is the same office with nothing to install. It is in private beta; join the waitlist.

Real development UI with the Lantern Studio example. Screenshots and video share a 1920 × 1080 (16:9) frame. Capture details and captions.

The brief, working draft, comments and version history live in one document. Live sync keeps collaborators on the same page.

Discuss a document or a passage, resolve comments and carry the requested changes into the next version.

Direct and group rooms give each discussion an explicit audience. Direction, questions and feedback stay together while documents and the company computer hold the work.

Open the company's Linux desktop inside Restless, inspect the result and Take control when you want to step in. Here, the studio's playable prototype is running.

Choose what the company may do on its own and which decisions need you. Authority & limits brings autonomy, outcome standards, model spend ceilings and standing grants into one place.

People connects each role to its current work and accountable lead.

A researcher, lead and reviewer can use different models and connections.

Resources & access reports each capability with its observed state, source and time. Doctor checks the execution path so you can find and fix a broken link.

Vault is based on Infisical. The owner can see the credential inventory without displaying secret values; Restless controls how credentials reach each provider or harness.

The work board shows current state; the dependency map shows how outcomes relate.

The company floor is an interactive view of colleagues and teams, connected to the same work as Attention, Work, People and Company.

Choose Restless when you want to run the business alongside AI, with your team working directly on the output.

Paperclip organises an agent company through roles, goals, issues, budgets and agent runtimes. It is a strong fit if you want that agent-management model. Its issue workflow lets a CEO agent create and delegate work, with humans reviewing progress and approvals.

Restless starts from a different question: what useful work can we finish together, and where does human judgement improve it?

• Work on the result. Your cofounder revises the brief, a colleague comments on the proposal, and you enter the company computer to try the build.
• Spend attention on purpose. The owner gets the output and a prepared decision; routine coordination stays with the accountable lead.
• Keep the team as small as the work allows. Start with one capable worker and add collaborators when they improve quality, check independently or save time.
• Give agents the company's own facts, voice and taste, and track which guidance each output used.
• Make quality an operating choice. Set an outcome standard, review the exact result and carry feedback into the next version.

Paperclip also offers human membership, ranked attention and versioned issue documents. The choice is the working relationship you want.

Restless separates three responsibilities:

The kernel bounds consequential actions. OrgIntel coordinates the work. The runtime provides the environment to do it.

Read ARCHITECTURE.md and coordination theory for the responsibility boundaries and team design.

Start with the working agreement, architecture, and the relevant sprint. The most useful contributions close a real workflow gap and show the resulting output or behaviour.

The hosted service and the public website live in a separate private repository. This repository contains the local company core, architecture and experiment evidence.

Restless Core is licensed under Apache 2.0. The Restless name, marks, visual identity, hosted service and private cloud control plane are not licensed by this repository.