A local coding agent, built in Rust

Your agent.
Your way.

Think it through. Build it out. A coding agent that works in your terminal, with your models, your tools, and your say in what happens next.

Get started Explore the docs

Open source. Made to be made yours.

bingo / dev 18e5bc6

A real bingo session, rendered with Ghostty WebAssembly.

Real dev TUI · deterministic provider · no live model or server shell.

Scroll sideways for the full 80-column terminal.

Read the transcript 
Read the existing code
╭──────────────────────────────────────────────────────────────────────────────╮
│ ✻ Welcome to bingo!                                                          │
│                                                                              │
│   /help for help · /login codex to use a subscription                        │
│   cwd: ~/project                                                             │
╰──────────────────────────────────────────────────────────────────────────────╯

> Trim whitespace in greet(), then run the tests.

⏺ I'll read the greeting, make the small fix, and run its tests.

⏺ Read(src/greeting.py)
  ⎿       1  def greet(name):
          2      return f"Hello, {name}!"

✻ Sketching… (esc to interrupt · 1s · ↓ 0.0k tokens)
╭──────────────────────────────────────────────────────────────────────────────╮
│ > ask anything · ⏎ steers · tab queues                                       │
╰──────────────────────────────────────────────────────────────────────────────╯
⏵⏵ acceptEdits (shift+tab to cycle)    ? for shortcuts    10k/191k · fake/fake-1

Read, edit, and test
⏺ Read(src/greeting.py)
  ⎿       1  def greet(name):
          2      return f"Hello, {name}!"

⏺ Edit(src/greeting.py)
  ⎿  --- /private/tmp/bingo-mws58eo4/project/src/greeting.py
     +++ /private/tmp/bingo-mws58eo4/project/src/greeting.py
     @@ -1,2 +1,2 @@
      def greet(name):
     -    return f"Hello, {name}!"
     +    return f"Hello, {name.strip()}!"

⏺ Bash(python3 test_greeting.py)
  ⎿  $ python3 test_greeting.py
     3 tests passed.
     [Exited with code 0]

⏺ Fixed whitespace handling. All 3 tests pass.


╭──────────────────────────────────────────────────────────────────────────────╮
│ > ask anything · / for commands · ! for shell                                │
╰──────────────────────────────────────────────────────────────────────────────╯
⏵⏵ acceptEdits (shift+tab to cycle)    ? for shortcuts    10k/191k · fake/fake-1

Your models.

Pick a provider. Change models as the work changes. Your workflow isn’t tied to one.

Choose a provider

Your workspace.

Work with real files and real tools. Sessions are journaled locally, ready to pick up again.

Meet the terminal

Your call.

Explicit permission modes put you in control of what the agent can do, and when it needs to ask.

Set the boundaries

Small at the core. Open at the edges.

Less in the way.
More to build on.

An agent should be a tool you can understand, not a box you have to trust. bingo keeps its kernel small and its boundaries explicit.

Inside the architecture
plugins

providers / tools / skills / MCP

kernel

sessions · turns · permissions · journal

surfaces

terminal / headless / JSON-RPC

one ordered event stream

One focused kernel

Sessions, turns, permissions, and the journal. A small foundation, not a growing collection of features.

Everything else is a plugin

Models, tools, and interfaces connect through the SDK. Extend the pieces you need without forking the whole.

One stream, every surface

The terminal, headless runs, and connected clients read the same ordered events. No parallel version of the truth.

Fits the way you work

Bring your own everything.

Keep the tools you know. Add the context you need. Let bingo meet you there.

Skills & MCP

Give the agent reusable instructions and connect the services you already use.

Headless, too

Run a turn from a script. Stream structured output into your own workflow.

Plugins in your language

A process, a pipe, and JSON-RPC. Extend bingo without writing Rust.

From a terminal to your workflow
bingo --print "review this diff"

# machine-readable, when you need it
bingo --print "review this diff" \
  --output-format stream-json
text / json / stream-json

Make yourself at home

The next move is yours.

Build from source, connect a provider, and open a session in your project.

Rust 1.96+ · Git · ~/.cargo/bin on PATH

Full installation guide

  1. Build

    git clone https://github.com/yexrob/bingo
cd bingo
cargo install --path crates/bingo --locked

  2. Connect

    bingo login codex

    Use your ChatGPT subscription with Codex, or configure an API provider. Choose a provider →

  3. Begin

    cd /path/to/your-project
bingo --provider codex

A small core. An open world.

View source on GitHub