# Bnome

> Bnome builds and runs software for businesses, for people, and for AI agents. Describe what you need in the browser and Bnome's own agent plans it, builds it and keeps it running — or connect your own agent (Claude Code, Codex, Cursor, Windsurf) over MCP and let it use the same platform. Everything built on it is a system: a few programs at their own addresses on one database, with durable queues, scheduled jobs, long-running workers, files, AI models and 1,500+ connected services, all run by Bnome.

## What a system is
Everything on Bnome is a **system**, not a single app: a few programs, each live at its own address on `bnome.app`, sharing one database. A bot and the page that configures it, an app for clients and the desk the team works from, the jobs that run on their own. One agent runs the whole system — it plans before it builds, writes and runs the code, checks that every program answers, and fixes what does not. Work keeps going when you close the tab: queues, schedules and workers run on Bnome, not on your laptop.

## What the platform gives a system
- **Programs** with production builds, their own addresses, and custom domains on paid plans
- **Databases** the agent chooses and keeps — SQLite, or Postgres and anything else it declares as a service
- **Services** from any public image: Postgres, Redis, RabbitMQ, Meilisearch, Qdrant, MinIO, whatever the product needs
- **Durable queues and events**: a message is kept, delivered to every handler, and retried (10 s → 6 h) until it is handled, so nothing is lost to a restart
- **Scheduled jobs** that call a program's own route every N minutes or daily at a time in your zone
- **Workers** — long-running processes the platform keeps alive
- **Files** one store per system; every program reads the same file at `/files/<path>`
- **AI without keys**: text, images, video, music, speech-to-text, embeddings and file search through Bnome's gateway, paid from the same credits
- **Connectors** to more than 1,500 services (Gmail, Google Calendar, Sheets, Stripe, HubSpot, Telegram, Notion, Slack, Airtable…), plus any other API the agent describes itself
- **Card payments** inside an app through Stripe Checkout

## Who it's for
- **Businesses** get the software they run on: the app their clients open, the desk their team works from and the jobs that run on their own, on one database — bookings with card payments, client portals, monitoring, an ads desk
- **People** get something that runs for them without servers: a bot that watches prices or news, a morning digest, a tool for a family, a club or a side project
- **People who build with an AI agent** get a place where the result keeps working — with a database, background work and a public address
- **AI agents** get Bnome's tools over MCP: read a system's map and data, hand work to its queue, set its schedule, keep its files, and ask Bnome's own agent to write the code

## MCP — any agent works on Bnome
`https://mcp.bnome.com/mcp` is Bnome's MCP server. One command connects it to Claude Code, Cursor, Codex or Windsurf:

```
npx @bnome/connect install --claude      # or --cursor, --codex, --windsurf, --all
```

It opens bnome.com/connect in the browser, you approve, and the agent's config gets a token (`~/.claude.json`, `~/.cursor/mcp.json`, `~/.codex/config.toml`, `~/.codeium/windsurf/mcp_config.json`). Restart the agent and the tools below are there.

Your agent signs in as you: your systems, your credits, nothing else reachable.

Two ways to work, and they mix.

**Bnome builds it for you** — `create_app`, `import_app` (from a public GitHub repo), `modify_app`, `get_build_status`, `list_my_apps`, `set_slug`.

**Your agent builds on Bnome** — `list_systems`, `describe_system` (a system's whole map in one read: its programs and their live APIs, services, every database with its tables, its topics, jobs, workers, files and connected services), `read_table`, `query_data` (read-only SQL), `publish_event` (hand a program work on the durable queue), `list_events`, `schedule_job`, `run_job`, `set_job`, `job_runs`, `delete_job`, `list_files`, `save_file`, `delete_file`, `set_setting`, `program_logs`, `ask_bnome_agent` and `agent_status` (have Bnome's own agent write and ship the code).

**The studios** — `generate_image`, `generate_video`, `generate_music`, `transcribe`, `derive_document`, `make_clips`, `make_film`, `redraw_frame`, `shoot_film`, `try_on`, `get_job`, `list_creations`, `get_credits`, `list_models`.

ChatGPT and claude.ai cannot connect yet: they need a hosted sign-in, which Bnome has not built. Agents that read a token — Claude Code, Cursor, Codex, Windsurf — work today.

## Examples

### Claude Code: something that runs on a clock
Say: *"On Bnome, make a bot that reads these five RSS feeds every morning and sends me a short summary in Telegram."*
- `create_app` starts the build; Bnome's agent writes the program and gives a link where you paste your Telegram bot token
- `get_build_status` until it is `running`
- `schedule_job` with `daily_at="08:00"` and your `timezone` calls the program's own route every morning; `run_job` tries it now, `job_runs` shows what it answered

### Background work: hand a long job to the queue
Say: *"Tag all 2,000 product photos in my shop's system overnight."*
- `describe_system` shows the system's topics and which program handles each one
- `publish_event` puts each photo on the topic; the platform keeps every message, delivers it to the handler and retries it (10 s, 30 s, 2 min … 6 h) until it is handled — a restart loses nothing
- `list_events` shows what is done, waiting or failed. Your laptop can be closed the whole time

### Codex: find and fix what broke overnight
Say: *"The 6:00 digest didn't arrive. Find out why and fix it."*
- `describe_system`, then `job_runs` for the digest job and `program_logs` for its program
- `ask_bnome_agent` with what was found ("the job answers 500: the feed URL moved; fix it and check it") — Bnome's own agent changes the code, checks the program and publishes it
- `agent_status` shows what it did

### A business: bookings, a desk and a reminder the evening before
Say, in the browser or through `create_app`: *"Bookings for my bike workshop with card payments, a desk for my team with today's jobs in order, and a reminder to every client the evening before."*
- Bnome's agent plans it as one system: the booking page for clients, the desk for the team, one database they share, a scheduled job for the reminders
- It asks for what only the owner has — a Stripe key for card payments, the Gmail account the reminders go from — on a connect page, never in the chat
- `describe_system` then shows both programs, their tables and the reminder job; `job_runs` shows every evening's run

### Several agents on one system
Claude Code on your laptop, Codex on a server and Cursor in your editor can all connect with your account and work on the same system at once: they read its data (`read_table`, `query_data`), queue work (`publish_event`), keep files (`save_file`) and set its clock (`schedule_job`, `set_job`). The code has one writer — Bnome's own agent, reached through `ask_bnome_agent` — so agents working in parallel never overwrite each other's changes.

### No agent of your own
Open bnome.com, describe what you need in a sentence and press Start. Bnome's own agent plans it, builds it and keeps it running; you watch it on a canvas and change it by talking in the chat.

## Agent discovery
- MCP server (streamable HTTP, Bearer token): `https://mcp.bnome.com/mcp`
- Connect an agent in one command: `npx @bnome/connect install --claude` (or `--cursor`, `--codex`, `--windsurf`, `--all`), or approve at https://bnome.com/connect
- [MCP tools](https://bnome.com/docs#mcp): every tool with its arguments
- [What agents do with it](https://bnome.com/docs#examples): the examples above, with the tools each one uses
- A token acts as its owner only — their systems and credits — and is withdrawn with «Sign out AI agents» on the profile

## Pricing
A credit is a cent. One balance pays for the agent's work and the AI inside your apps. The agent's work is charged by the computing it really used: a small fix is often under 100 credits, a new program usually 300–800.
- **Free** — 500 credits a month plus 1,000 to start, up to 3 programs, your address on bnome.app; sleeps after a day without visitors and wakes in seconds
- **Pro, $30/month** — 3,000 credits, up to 25 programs, always on, your own domain
- **Business, from $99/month** — 12,000 credits (then $199 for 24,000, $499 for 60,000), up to 100 programs
- Packs top up the balance and never expire. Run out and the agent waits; your apps stay up.

## Useful links
- Site: https://bnome.com
- Pricing: https://bnome.com/pricing
- Docs: https://bnome.com/docs
- MCP and the tool list: https://bnome.com/docs#mcp
- Connect an agent: https://bnome.com/connect
- Blog: https://bnome.com/blog/

## Featured writing
- [Replit Alternative: Bnome vs Replit Agent for Business Apps](https://bnome.com/blog/replit-alternative/)
- [Airtable Alternative: When a Base Should Become an App](https://bnome.com/blog/airtable-alternative/)
- [AI App Builder for Business: What Actually Has to Work](https://bnome.com/blog/ai-app-builder-for-business/)
- [Preview vs Production: Why Your AI-Built App Breaks When Real Users Show Up](https://bnome.com/blog/ai-built-app-breaks-in-production/) — localStorage data, runtime-injected secrets, bypassed auth and mock integrations, with a pre-ship checklist.
- [The Complexity Wall: Why AI App Builders Get More Expensive as Your App Grows](https://bnome.com/blog/ai-app-builder-cost-token-math/) — how token, credit and effort pricing scale with codebase size across Bolt, Lovable, v0 and Replit.
- [Bnome vs Lovable: Which AI App Builder Should You Actually Use?](https://bnome.com/blog/bnome-vs-lovable/)
- [Bnome vs Bolt.new: Which AI App Builder Should You Actually Use?](https://bnome.com/blog/bnome-vs-bolt-new/)
- [Bnome vs v0: Which AI App Builder Should You Actually Use?](https://bnome.com/blog/bnome-vs-v0/)
- [GEO for AI-Built Apps: How to Get Cited by ChatGPT, Claude & Perplexity](https://bnome.com/blog/geo-for-ai-built-apps/)
- [I Typed Two Words and Got a Working Chess Game](https://bnome.com/blog/build-a-chess-game-in-one-prompt/)

## Contact
Through bnome.com, or hello@bnome.com.