Current releases: cloud CLI 0.1.33 and platform 2.7.241. Read the complete Codex and Claude workflow or the self-hosting guide for your own infrastructure.

For Claude Code & Codex users

Install Benmore for
Codex and Claude Code.

Benmore is one binary plus a hosted dev environment. Install it, bootstrap once, launch Codex or Claude Code - then just say what you want. Use the hosted dev URL to review changes, run browser checks, and publish after verification. Read the complete agent workflow for the commands and recovery boundaries.

$ brew install benmore-studio/benmore/benmore-cli
$benmore bootstrap# browser sign-in / sign-up + installs the agent skill
$cd ~/Benmore
$codex# or claude
Homebrew on macOS · Linux/CI: curl -fsSL https://benmore.ai/install-cli.sh | sh · framework source on GitHub

How it works

No local server, no Docker, no build step. The dev environment is hosted - you watch the app take shape in a browser tab while the agent works.

1

Install & bootstrap

benmore bootstrap signs you in through the browser (where you can also create your account), sets up your ~/Benmore workspace, and installs the shared agent skill for Codex and Claude Code. Codex discovers it under ~/.agents/skills/benmore-cli; both follow the app's AGENTS.md. Run benmore docs harness for the operating contract.

2

Say what you want - it's live while you build

Every app is born live in a hosted dev environment. Installed Claude Code hooks push edits made through supported editing tools; Codex and other agents run benmore push <file> explicitly. Open the dev URL on your laptop or phone and watch it evolve in real time.

while you build
https://<app>-dev.benmore.ai
Your sandbox. The agent builds, tests, and iterates here.
when you say "publish"
https://<app>.benmore.ai
Production. Code promotes dev → prod; data is migrated with a backup.
3

Publish when you're ready

Say "publish it" and the agent promotes your code to production with auto-SSL - dev stays your sandbox. Source history supports reviewed reverts. A source revert does not restore the database or undo external side effects.

Don't learn commands. Say what you want.

These are real prompts. The skill teaches your agent the tools behind them - you never have to.

Build me an invoicing app with client logins and overdue reminders. Show me when it's live.
Behind the scenes: the agent writes a Prisma schema + TSX frontend and pushes. The runtime generates the REST API, auth, and real-time updates - no handler code. Live on your dev URL in minutes.
Open the app in a real browser, sign up as a test user, and verify onboarding end-to-end. Record it so I can watch.
Behind the scenes: browser_check drives headless Chrome against your dev app - JS executed, clicks and typing included - and records a scrubbable session replay. You get a link and literally watch what the agent did.
Make a shareable demo video of the checkout flow and put it on a page I can send to a client.
Behind the scenes: a shared recording mints a public, login-free replay link plus an embed. The agent pastes it into an edge - an isolated shareable page on its own URL. Inputs are masked at capture.
POST /api/invoices returns 403 for managers - figure out why and fix it. Prove it works after.
Behind the scenes: the agent probes the route as a real signed-in user, tails server logs, queries the live database, fixes the access rule, and re-probes to show the 200.
Undo whatever you just did.
Behind the scenes: successful source pushes record app git history. Review and revert the relevant commit, then verify the app. Stored data and external side effects need their own recovery plan.
Before we publish: run a security scan and fix anything it finds.
Behind the scenes: the platform's security scan plus write-time validators. The runtime already enforces parameterized SQL, CSRF, per-user scoping, and rate limits by default - the agent can't ship past the gate.

Why agents ship faster here

The runtime does the undifferentiated work, so the agent's edits are small, declarative, and verifiable. Less surface to get wrong, more it can prove.

auto-CRUD API
Every model gets REST endpoints - list, create, batch, search, pagination - with zero handler code to hallucinate.
auth built in
Sessions, signup, OAuth, MFA, roles & RBAC, CSRF - enforced by the runtime, not agent-written code.
browser verification
Headless-Chrome checks with screenshots and recorded session replays - the agent proves the UI works, you watch.
real-time
SSE and WebSocket events for every table, scoped per user and tenant.
write-time validation
Every push runs framework validators first - antipatterns are rejected with a fix hint the agent acts on.
git history per app
Review committed source history and revert code changes. Database recovery is a separate operation.

Not in a terminal? Same platform.

Claude Code & Codex (this page)
benmore bootstrap installs the skill and references for both harnesses. Codex can invoke $benmore-cli and pushes explicitly; Claude uses its installed edit hooks. Skills do not grant tool permissions.
Claude.ai, Cursor & MCP clients
Add the Benmore MCP server as a connector and drive the same platform from chat.
MCP server URL
https://benmore.ai/mcp

Three commands, then it's conversation.

Install, bootstrap, launch your agent - your first app can be live before the coffee's done.

Read the docs GitHub