Explore repeat lookups.
FREE, OPEN-SOURCE MAC APP
Your agent builds the app.
You keep the controls.
Build in Codex, Claude Code, Cursor, or your usual editor. Project Room opens the same repository and gives you one window to run the app, check tests, inspect data, and follow the product plan.
Apple Silicon preview Runs locally on your Mac MIT licensed
HOW IT CONNECTS
One control surface for your local stack.
Your coding agent edits the repository. Project Room opens the same files and gives you controls for the running app, tests, and data—even when you return next week.
Everything at a glance.

INTERACTIVE WORKSPACE TOUR
See the whole workspace. Then try it.
Follow a product from its plan through the connected services, data, and tests. Play the story or open any view yourself.
Everything at a glance.
Development, quality, and product progress in one place.
FR-001 is built. Check the API response against PostgreSQL.
Find the source behind the story.
The same project files your agent edits are one click away.
project: {name: Atlas}
components:
- id: web
kind: service
name: Web app
build: {file: dist/web/build-info.json}
- id: api
kind: service
name: API service
- id: postgres
kind: databaseThe build pipeline writes the timestamp and revision to its build file after a successful build.
Open a repo. Know what to check.
A guided checklist turns a new folder into a usable workspace.
Verify the app, not just the YAML.
Start each service, run the checks, and inspect a real data source before trusting the map.
Give the agent a reason to build.
The product purpose lives in a Markdown file everyone can revisit.
docs/vision.mdEdit MarkdownMake every order easy to find and trust.
For support teams who answer customer questions about orders.
The problem is that finding an order means checking several systems.
First useful release lets a team find one order and see a reliable status.
Show what comes next.
Place product outcomes in a clear status so the next task has context.
Share an order result.
Find an order and trust its status.
Web · API · PostgreSQLAgree on the first outcome.
Roadmap status is a plan. Tests and runtime show what actually works.
Measure whether people get value.
One outcome metric keeps product progress visible beside delivery.
Target: 100
Latest manually recorded value · example data
The target is a goal; the plotted values are manually entered observations.
Know what comes next and why.
Requests, decisions, and bugs stay beside the code.
Support teams want to repeat common order lookups.
Idea · medium priorityFind an order by ID and trust the returned status.
Linked to specs/001-order-lookupMake the exact failing check easy to inspect.
Bug · high priorityFollow the promise into the build.
The standard Spec Kit files connect product intent to implementation work.
Customers can find one order by ID.
FR-001 A valid order ID returns the matching order and its status.
T004 Verify the response against local data.
Keep the explanation with the work.
Product and technical notes remain readable in the repository.
Run Atlas locally
1. Open the repository in Project Room.
2. Set DATABASE_URL locally.
3. Start Web, API, and MCP services.
4. Run the registered checks and inspect the order table.
See how the system fits together.
Connected components show their state and, when available, the artifact build.
Know which build you started.
Build time and commit are separate from the moment a process starts.
Example build metadata · select Start for a simulated local service.
Spot what the system needs.
Required variable names are visible; values stay on this computer.
In the desktop app, you set your own secret locally. The repository stores only its name.
A manual you can actually use.
Browse a project's commands and try one without guessing flags.
Last build · 04 Nov 2026, 20:36:04
Commit · d7a2f80
Version · v1.4.2
atlas orders get <order-id>Argument order-id · required
Option --json · machine-readable output
$ atlas orders get ORD-1042 ORD-1042 Ada paid Last example run · repeat the command
See what the MCP server exposes.
Inspect tool inputs and run a sample call deliberately.
Last build · 04 Nov 2026, 20:32:07
Commit · c39e2a4
Version · v0.7.0
get_order({ id: "ORD-1042" })atlas orders get ORD-1042See the contract. Try the endpoint.
OpenAPI gives you the routes; one deliberate request shows the actual response.
Document: specs/001-order-lookup/contracts/openapi.yaml
http://localhost:4000/orders/ORD-1042Bearer token name: ATLAS_API_TOKEN · value stays local
{ "id": "ORD-1042", "customer": "Ada", "status": "paid" }Open the data behind the app.
Browse a local structure without leaving your workspace.
Check every part of the stack.
Run the registered checks and see their results together.
Last sample run · MCP lookup needs a rerun
› Last sample run: 3 passed. Start MCP and rerun all checks.
See what happened since you last looked.
Starts, inspections, and test runs leave a trail you can review.
From FR-001 to a running API, a visible order, and a check ready to rerun.
Make the workspace yours.
Keep the core navigation clear; enable extra views when they help.
The tour shows these optional views so you can see how product direction fits alongside runtime.
Explore the desktop navigation through one example workspace. Tour actions are simulated; the desktop app operates your real local repository.
GET STARTED
From download to your first run.
Try the included example, then use your coding agent to prepare a new or existing repository. Project Room opens the same folder and turns its verified configuration into a workspace.
1. Download the Mac app
Get the free Apple Silicon preview. The desktop app and its source are open on GitHub.
Download free for Mac2. Install and open it
Unzip, move the app to Applications, and launch it. Try the included example first; Node.js 20+ runs its example commands.
3. Open your own project
Copy the matching prompt below into your coding agent while it works in your repository. For an existing project, review its findings first. Once it creates .projectroom/project.yaml, open that folder in Project Room and check the detected services, tests, and data.
Start in your coding agent.
Run the prompt in your project folder. Your agent prepares the repository; Project Room reads it. You keep building in Codex, Claude Code, Cursor, or your usual editor.
Build from an idea
Give the agent your app idea. It asks about the first useful release, starts the official Spec Kit workflow, and adds Project Room as the app takes shape.
Read the prompt
Build [my app idea] for [my audience] in this folder with Git, the official GitHub Spec Kit (https://github.com/github/spec-kit), and Project Room. First ask me who it is for, what problem it solves, and what the first useful release should do. Read the Project Room guide (https://github.com/OpenProjectRoom/desktop/blob/main/agent/project-room/SKILL.md) and schema (https://github.com/OpenProjectRoom/desktop/blob/main/schemas/projectroom.schema.json). Keep the constitution, specs, plans, and tasks in Spec Kit's standard files. Create .projectroom/project.yaml from real code and commands as they appear; no parallel spec tree, invented components, or secrets. Use manual startup and validate the YAML. Finish with the Mac download and installation steps, the exact folder to open in Project Room, what you configured, what remains uncertain, and what I should verify there first.
Connect what you already built
Paste this into the coding agent already working in your repository. It inspects your project, explains what it found, and waits for your answer before changing files.
Read the prompt
Add Project Room to this repository. Read the agent guide (https://github.com/OpenProjectRoom/desktop/blob/main/agent/project-room/SKILL.md) first. Inspect the project without changing files. Summarize what you found, whether it uses GitHub Spec Kit, what Project Room could show, and what is uncertain. Ask only the decisions you cannot safely infer. Wait for my answer before creating or updating the configuration. Then follow the guide. Finish with the Mac download and installation steps, the exact folder to open in Project Room, and what I should verify there first.
When the agent finishes: download the Mac app if needed, unzip it, move it to Applications, and launch it. Open the exact folder the agent names. If that folder is already open, refresh analysis. Check Onboarding and Project Map, then manually try a configured service, test, and data source.
Apple Silicon preview is unsigned and not notarized. View source and star on GitHub ↗
FOR PRODUCT OWNERS
Shape what gets built.
Follow what gets done.
Keep the why, the next steps, and the evidence together in the repository. Your coding agent works from the same product context that you can inspect in Project Room.
Progress overview
See services, recent tests, and open work together. Task progress is read from your existing Spec Kit tasks.md files.
Vision
Write the product purpose in a Markdown document the team and agent can revisit. Enable this view when you have a vision to show.
Roadmap
Turn product milestones into a shared plan. Link them to components and show their declared status as the work moves forward.
North Star
Choose one product outcome, set a target, and record observations over time. The chart plots values entered by the team.
Backlog
Capture requests as Markdown issues with status and priority, then link them to specs. GitHub and Linear can be referenced; live sync is still planned.
Documentation
Read and edit product documentation in the project folder. Keep decisions and onboarding notes alongside specifications and code.
RUN & VERIFY
Look inside the software.
Check what actually works.
Go from product progress to the running system. Inspect the services, tests, tools, data, and files behind each release.
Interface previews are illustrative. Planned capabilities are labeled.
Project Map
See the real services, databases, storage, and persistent processes that make up your local system.
Services & logs
Start and stop local services, read their output, and see the build timestamp, commit, optional version, and separate process start time when available.
View full demo screenshot ↗View full demo screenshot ↗Test Explorer
Run suites or individual discovered tests and inspect their output. Configured links show test evidence beside related requirements.
MCP Explorer
Connect project MCP servers, browse their tools and resources, inspect build identity when provided, and try a tool deliberately.
CLI Explorer
Discover local command-line tools, read their options like a friendly manual, and identify the artifact build before running a trial.
API Explorer
Discover project OpenAPI files, register multiple HTTP APIs, send a request on purpose, and inspect status, timing, and response. Bearer tokens stay local.
Data Explorer
Collect every configured project source in one place. Inspect supported databases and local files with limited, read-only previews.
Environment variables
See the variable names your project needs and edit local values in its .env file. Keep secrets out of YAML, Git, and Product Chat.
Spec Kit & requirements
Read existing specs, plans, tasks, and project rules; follow the progress of work stored with the code.
Workspaces & files
Switch local repositories and browse their source trees, with folders collapsed until you open them.
Product Chat
Keep coding in Codex, Claude Code, Cursor, or your editor. Product Chat is an optional way to ask a local agent about the same project; type or dictate in the desktop app.
Activity history
See recorded starts, test runs, agent connections, and project changes so the next session has context.
CPU & memory history
Watch CPU and resident memory for services Project Room starts. Samples stay in memory for this app session and reset when the app restarts.
SPEC KIT INTEGRATION
The missing control panel for GitHub Spec Kit projects.
Follow specs and tasks in their standard files. Start your app, inspect its data, run tests, and see what your agent has actually built.
Spec Kit gives your agent a plan.
Project Room gives you the controls.
Project Room reads the standard Spec Kit files in your repository; it does not create another spec tree. Services and explorers also work without Spec Kit.
HOW IT WORKS
- 01Set directionVision and next milestone
- 02Specify workStandard Spec Kit files
- 03Map the appVerified commands and data
- 04Run and reviewServices, tests, evidence
“I’m a bit of a control freak. I built app after app with coding agents, then kept asking the same questions: What’s running? Which build am I looking at? How do I stop it, inspect the data, or run its tests? I used to have those controls close by in an IDE or terminal.
So I made little dashboards for each project. Eventually I realized I needed one reusable project file and a local viewer that makes the software visible and operable. Now the product vision and Spec Kit work can sit beside the running app, too.”
SHARED WITH THE CODE
One small file.
A way back in.
Your coding agent checks the real project, then records verified services, tests, data sources, and product documents in .projectroom/project.yaml. Your team commits that file with the code. Secret values stay in the project's ignored .env.
schemaVersion: 1
project: { id: atlas, name: Atlas }
product:
vision: docs/vision.md
components:
- id: web
kind: service
name: Web app
position: { x: 15, y: 80 }
runtime:
command: [npm, run, dev]
cwd: .
startup: manual
FAQ
What Project Room
actually does.
Does it replace my terminal or editor?
No. Keep writing code in Codex, Claude Code, Cursor, or your editor. Project Room opens the same local repository to show product context and run configured commands. Product Chat is an optional way to ask a local agent about the project.
Does it automatically know how every repo starts?
It can discover some project structure and tools. A coding agent can help draft .projectroom/project.yaml, but you verify the commands, dependencies, and data sources before using them.
What happens to my Spec Kit files?
They stay in the repository. Project Room reads the existing constitution, specs, plans, and tasks from Spec Kit's standard files. Services and explorers work without Spec Kit, too.
Does it deploy my app to the cloud?
Project Room focuses on your local development system. Your cloud platform still handles deployment and hosted operations.
Start with an idea.
Keep building for years.
A clear framework for the work, and a local control room for the software that grows from it.
