Bend: A Proof-Checked Language That Blocks AI Mistakes on CPU and GPU

Bend is a compiled, parallel language pitched at AI-generated code. Its core claim: instead of trusting output you never read, you declare laws in a LAWS.bend file and require the agent to prove them before merge.

The pitch sounds like every other AI-coding tool, but the mechanics differ. Bend's type checker is a proof checker, the same idea as Lean or Rocq. The difference it emphasizes is speed: those checkers can take minutes on mid-sized codebases, while Bend claims a second at most so an agent can run checks after every change.

Where the speed comes from

• Compiles to native code. Nearly C-speed on one core.
• The same binary scales to sixteen cores or the GPU. The docs claim up to 100x faster than a single core.
• Parallelism is automatic. You split work in two; Bend spreads calls across cores or GPU cores, then joins them. No threads, no locks, no kernel code.

The site shows a pow2.bend example running on 4,096 GPU cores.

The laws and proof model

You write a law in LAWS.bend:

# LAW: no move sequence leads to victory.
law you_cant_win : for moves: List<Move>
    board = replay(start(), moves)
    is_won(board) == False

The agent then writes the matching proof in PROOF.bend:

# PROOF: you_cant_win holds.
def Laws.you_cant_win (moves):
    # ... written by the AI

Once a law is declared, the site argues the agent can't merge a line that breaks it. The demo uses a game: ask Claude to make the board wrap around. Without LAWS.bend, the bug merges and ships. With it, the agent must retry until it builds a proof. The phrasing in the source: merging a bug becomes "mathematically impossible."

Setup

Install:

curl -fsSL https://bend-lang.com/install.sh | sh

Then add this block to your AGENTS.md so agents know what to do:

When using Bend:
- run `bend guide` to learn it
- use `LAWS.bend` to keep important rules
- run `bend PROOF.bend` before committing
- parallelize the code whenever possible

Bend essentially treats LAWS.bend as an AGENTS.md backed by proof. "Make no mistakes" becomes type-checked.

Caveats from the source

The docs are upfront: Bend is young, expect bugs, and report them. It works best on the back-end and targets Linux and macOS. The core is backed by two papers — BendTT (affine dependent type theory) and BendRT (parallel CPU/GPU runtime).

Who it's for

Teams letting agents ship code they don't read, especially back-end services where a rule like "balances never go negative" needs enforcement rather than a code review.