╭────────────╮                                               
│ ██████ ███ │   ██████╗ ███████╗███╗   ██╗████████╗ ██████╗ 
│ ██████ ███ │   ██╔══██╗██╔════╝████╗  ██║╚══██╔══╝██╔═══██╗
│ ██████ ███ │   ██████╔╝█████╗  ██╔██╗ ██║   ██║   ██║   ██║
│ ███ ██████ │   ██╔══██╗██╔══╝  ██║╚██╗██║   ██║   ██║   ██║
│ ███ ██████ │   ██████╔╝███████╗██║ ╚████║   ██║   ╚██████╔╝
╰────────────╯   ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝    ╚═════╝ 

Bento

Orchestrate your coding agents.

Bento is an application for running AI coding agents across your software development pipeline. Engineers are shipping features faster with coding agents. However, engineers are losing track of all their sessions and the quality of PRs are dropping.

With Bento, You define the stages of your software development process, for example: product investigation, UI/UX design, engineering requirements, implementation, code review, and quality engineering. Each stage gets an agent, model and a skill to define what work needs to be done. Features move across each stage as agents work on them, each feature has its own sandbox.

Mac application

Download Bento for Mac (Apple Silicon and Intel). The Mac app runs Bento locally or signs in to hosted Bento.

See the Mac application guide for packaging and setup.

CLI

Requires Node.js 22.19+, curl, tar, and macOS or glibc Linux (x64/ARM64). Local mode also needs Docker running.

Windows: use WSL 2 setup, then run the commands below inside Ubuntu.

curl -fsSL https://usebento.ai/install.sh | sh

Follow the installer's PATH instruction. For local agents, build the sandbox and open setup (use /usr/local/lib/bento/sandbox if installed there):

docker build -t bento-sandbox:dev "$HOME/.local/lib/bento/sandbox"
bento setup

Connect a repository, configure agents and credentials, then return to the board. Run bento next time; use bento update to upgrade.

See the Bento CLI guide for settings, shortcuts, and cloud setup (no local Docker required).

Web UI

You will need Docker installed to run Bento.

echo 'BENTO_REPOS=/Users/your/repositories' >> .env # Mounts directory into docker container
docker compose up --build

Open http://localhost:4400.

That builds the server, the console, and the sandbox image agents run in, starts Postgres, applies migrations, and serves. Everything else you configure in the console.

Agents work in sandboxes that the server creates through your Docker daemon, so each repository has to exist inside the server container at the same path it has on your machine. Set BENTO_REPOS to an absolute directory containing your checkouts. If you add or change it after starting Compose, run docker compose up -d --no-build --no-deps --force-recreate server to apply the mount.

Building your first feature

1. Point Bento at a repository

Create a project and add your repositories (ensure you set BENTO_REPOS and your repos live within that directory). A project can span several repositories and each repository gets its own worktree inside the card's workspace. A card can work on multiple repositories in a project.

2. Give the agents a model API key

Under Agents → Model provider keys (or the model provider step when you first sign in), save a provider API key. Keys are stored encrypted, never shown again, and personal by default; a team owner or admin can share a key with the whole team. Or connect your own Claude or ChatGPT subscription under Agents → Your personal subscriptions. In local mode you can also paste a Claude token from claude setup-token. For which tool needs which credential, see docs/agents.md.

3. Check the existing agents

A new project starts with three stages (engineering requirements, implementation, code review), each with an agent and each opening a pull request. The Product Manager, Product Designer, and QA Engineer agents are created too, ready for a stage you add. Open the Agents tab to see them.

An agent is a harness, model, and a skill. The skill is its standing instructions, sent with every agent start. Use it to say what the stage's write-up must contain and what outcome or actions the agent must produce. The defaults are short on purpose so that you can start immediately, but over time you will want to fine tune the skills for your own process.

The defaults use Claude Code on Sonnet. Updating an agent is reflected in every stage that uses the agent.

4. Shape the pipeline

Open Pipeline. Each stage sets which agent runs it, and how a card advances from the stage: either manual approval or automatic once the requirements you define pass. You can reorder the stages by dragging a stage by its grip.

All stages start out manual, so your first card stops at each one and waits for you to look. Once you trust a stage and the agent output you can make it automatic and cards advance automatically. For more on pipelines like gate criteria, judge agents, and exporting a pipeline as YAML, see docs/pipeline.md.

5. Give agents the context to build your application

Under Repositories, give each checkout a setup command and a test command. Sandboxes ship with git and the coding agents but no language runtime, so this is where a project asks for Node, or Go, or npm ci. The test command goes to the agent, which runs it to check its own work before the stage ends.

6. Run a feature through it

Add a card, describe the feature, and advance it. The stage's agent starts and its transcript streams into the card's drawer. Approve it and the card moves to the next stage, where a different agent picks it up. The previous stage's write-up is already committed to the branch.

Turn on "Create a pull request" for a stage and a successful run there pushes the branch and opens a PR for each repository the agent touched. See docs/pull-requests.md.

Going deeper

Bento Quick Overview	Cards, sandboxes, worktrees, spend, tenancy
Bento CLI	Install, configure, run local or cloud agents, and keyboard shortcuts
Pipelines	Stages, gates, judge agents, the pipeline file, repository commands
Coding agents	What each tool can do, how each authenticates, talking to a working agent
Security	Proxy tokens, the MCP gateway, git access, network access
Pull requests	Publishing, what stays out of the diff, connecting GitHub
Swarms	A planner and workers on one feature tree, the merge queue, publishing
Web app setup	Running it for a team, multi mode, troubleshooting, contributing
macOS app	Electron desktop setup, packaging, and verification

Security model

The sandbox is the security model. Agents can run any command they generate but the sandbox prevents any rogue action from being defective. Here are some good practices to ensure the agent stays within the sandbox:

• Never expose the host Docker socket, host SSH keys, or host git config to a sandbox.
• Git access uses short-lived GitHub App installation tokens, scoped to one repository.
• Prefer proxied API keys or personal account connections over mounting subscription credential files. A prompt-injected agent can read anything the sandbox can.

What a sandbox holds and can reach, model keys, MCP credentials and the network lock included: Security.

Report an issue

Found a bug? Open an issue at github.com/danielpang/bento/issues.

License

Elastic License 2.0. Free to use, self-host, and modify. You may not provide it to others as a managed service.