DEV Community: Jonathan Murray

am I on the hook for a Private Jet?

Jonathan Murray — Sat, 04 Jul 2026 16:42:33 +0000

So a few months ago my co-founder Rob stood up in a meeting and told our interns that if they got Backboard to the #1 spot on Terminal-Bench 2.1 we would rent a private jet and take the whole team somewhere to celebrate.

It wasn't a joke. It was a challenge. It was just an insane one. Terminal-Bench is the most sought after eval in AI right now, the thing every trillion dollar frontier lab is openly gunning for, and Rob told a group of interns to go beat all of them. That's not a bet, that's a polite way of saying this will never happen so sure, jet's on me.

The interns did not receive it that way.

What we didn't know, and I mean genuinely did not know, is that they spun up a separate codebase and named it the PJ Branch. PJ as in Private Jet. They worked on it nights and weekends. They were sleeping at the office. Actual sleeping, at the actual office, and we had no idea because they'd just... be at standup at 9am like normal humans who slept in beds.

The only clue was the workspace. We'd wake up and scroll through these full on chat streams, benchmarks running at 2am, 3am, someone posting results at 4:30 in the morning, and then five hours later that same person is on the daily standup with their camera on acting completely fine. What the hell is going on. We thought the timestamps were broken.

The timestamps were not broken.

And keep in mind what they were up against. While our interns are ripping benchmarks on an air mattress, the frontier labs are shipping models so good the US government literally stepped in on one of them. That's the competition. Kids on a couch versus labs with more compute than some countries.

Yesterday it happened. 84.3% on Terminal-Bench 2.1. The highest score ever recorded, above every published result. Above Codex. Above Claude Code. And here's the part that actually breaks my brain: they didn't even use the newest model to do it. They beat the shiny new government-attention-getting frontier model with the previous generation. Beat the new thing with the old thing. What the fuck. We posted every per-task verifier log to GitHub so you can go check it yourself, because we knew nobody would believe it, we barely believe it.

Which brings us to the current situation at the company, which is that Rob and I are looking at private jet charter prices and doing that thing where you laugh but your eyes aren't laughing. Do you know what those things cost? Holy shit.

Are we on the hook? Legally, I've been told a verbal agreement witnessed by an entire engineering team is "not great for us." Morally, obviously yes. These kids beat trillion dollar labs at their own game on a branch literally named after the reward. You cannot stiff the PJ Branch.

And honestly if we don't pay up, what's our word worth? Our whole thing is receipts. We publish verifier logs for every single benchmark task because we think claims should be checkable. Can't run that flag up the pole and then welch on a jet. That would be a bitch move and everyone would know it.

So that's where we are. Rob and I staring at charter quotes, doing startup math, trying to figure out if we can actually pull this off. No decision yet. The interns know we know. Every standup now has a certain energy to it.

Rob did float one idea, which is those studios influencers rent that are just the front half of a fake private jet bolted to the floor of a warehouse. $60 an hour, unlimited photos, nobody has to know. And look, our interns beat the benchmark without the newest model, so there's a version of this where we honor the bet without the actual jet. Very on brand. They did not think it was funny... I think thats off the table hahaha

In the meantime, the thing they built is live and you can use it. It's the exact harness that put up the score, logs are all on GitHub. Use code 1ONTBENCH for dev credits. Every signup gets us closer to affording the damn jet, so honestly, this one's for the interns.

The team is unreal.

Jonathan Murray — Sat, 04 Jul 2026 03:51:24 +0000

Erin T

Jul 4

David Just Beat Goliath on Terminal-Bench 2.1

#news #ai #programming #opensource

2 min read

#1 Coding Agent, Beating Fable

Jonathan Murray — Fri, 03 Jul 2026 20:23:03 +0000

I'll let the Git Repo do most of the talking here... But Backboard's R-CLI is currently SoTA for Coding Harnesses.

https://github.com/Backboard-io/Backboard-R-CLI-Terminal-Bench-2.1-Results

Use promo code: 1ONTBENCH for dev credits - backboard.io/

We bet against the GPU arms race. Here's what shipped.

Jonathan Murray — Thu, 02 Jul 2026 13:15:25 +0000

On July 1 we announced four things at once. The press release version is here. This is the version for people who actually build things.

The short story: while the industry spends hundreds of billions on new hardware, we took the opposite bet. Get more out of the GPUs that already exist, and keep everything inside the customer's own environment.

Here's what came out of it.

BackboardQuant: compression that doesn't lobotomize the model

Everyone who has quantized a model knows the trade: smaller and faster, but dumber. The interesting engineering problem was making that trade disappear.

BackboardQuant (yes, we call it BBQ) compresses models by up to 70% with functionally no quality loss. In our testing, compressed models retained full-precision performance while running up to 2.7x faster.

What that means in practice: one GPU doing the work of two or three. If you're serving models at scale, that's your inference bill cut by more than half without touching your architecture. It ships built into our enterprise deployments.

Backboard Studio: the benchmark result we didn't expect

We built Studio because frontier-lab coding tools are excellent and priced like it. The goal was matching them at a fraction of the cost.

The result on Terminal-Bench 2.1, the neutral public harness for agentic coding:

Backboard Studio running Claude Opus 4.8: 79.8%
Opus 4.8 on its own harness result: 74.6% The harness matters more than people think. Same model, better scaffolding, five points better.

The part I care most about: running GLM 5.2, an open-source model, Studio clears 72%. That's frontier-class agentic coding with no proprietary model in the loop. Pair that with a built-in token optimizer that cuts frontier model usage by up to 30%, and "up to 90% cheaper" stops sounding like marketing.

Studio runs in the cloud or fully self-hosted, so proprietary code never leaves your infrastructure. It's available now.

Nash: one app instead of shadow AI

Every enterprise we talk to has the same problem: employees are pasting company data into whatever chat app they found. The fix isn't a ban, it's a sanctioned option that's better than what they'd find on their own.

Nash gives users thousands of models across text and image in one chat app, with memory that stays out of the model providers' hands. Consumer and enterprise, live at hellonash.ai.

Memory: still #1, and you can check

Backboard ranks first on LoCoMo and LongMemEval, the two leading independent AI memory benchmarks. We published the results and the harnesses so you can reproduce them yourself:

LoCoMo results
LongMemEval results If you find a problem with our methodology, open an issue. We mean that.

The throughline: sovereign by design

None of these are separate products bolted together. The whole stack, API, application layer, and models, can run inside a customer's own cloud. Data never leaves. For governments, hospitals, and banks, that's the difference between "we'd love to use AI" and actually using it.

One more thing, because it matters to us: all of this was built in Nepean, Ontario, by a team made up entirely of graduates of Canadian universities, colleges, and CEGEPs. The default assumption is that this kind of work only happens in San Francisco. It doesn't.

Try it

If you write code, Backboard Studio is the fastest way to see whether any of this holds up. Run it against whatever you're using now and compare the bill.

Questions about the benchmarks, the compression numbers, or the harness? Ask in the comments. I'll answer.

The Prophet and the Price Cut

Jonathan Murray — Mon, 29 Jun 2026 00:36:34 +0000

Two things happened this month and they tell you everything about where AI is actually going.

Coinbase quietly cut its AI bill nearly in half. Open models, smarter routing, better caching. No drama. A finance footnote that happens to be a glimpse of the future.

And Dario Amodei published another essay.

Not a tweet. An essay. The kind of sprawling, twenty-thousand-word civilizational scripture he keeps handing down from the mount. This one is called "Policy on the AI Exponential," and the gist is that AI is about to hand humanity "almost unimaginable power," that our institutions are too immature to hold it, and that therefore the government should be able to test, gate, and block frontier models before mere mortals get hurt.

One of these is a price cut. The other is a prophecy.

I want to talk about the prophecy.

The robes

Let me be fair before I am not.

Dario is not a dumb man and he is not a fraud. He runs one of the best labs in the world. The safety concerns are not all imaginary. Misuse is real. I am not the guy arguing that anyone should be able to download a bioweapon recipe for a laugh. If that is the bar, sure, regulate it. Nobody serious disagrees.

But watch the move he keeps making.

Every few months the prophet descends with a new text. The stakes are always civilizational. The language is always biblical. "Unimaginable power." A "decent possibility" of "significant enduring job loss." Disruption that will be "unusually painful." Humanity handed a force it is not mature enough to wield.

He is not describing a product roadmap. He is describing a flood. And conveniently, he is also selling the ark.

That is the part that should make you tilt your head.

Read the actual proposal

Strip the poetry off "Policy on the AI Exponential" and here is the machinery underneath.

Mandatory third-party testing for any model above a compute threshold. Authorized evaluators. Security standards. Incident reporting. Government authority to block or reverse a deployment that fails the tests.

Now ask the only question that matters. Who can absorb that?

A company with a policy team, a compliance org, a government affairs budget, and a war chest can absorb it. They will hire for it. They will help write the rules they then comply with. It becomes a cost of doing business, and a comfortable one, because it lands hardest on everyone smaller.

The kid shipping an open weight model from a laptop cannot absorb it. The startup running GLM or Kimi at a fraction of frontier cost cannot absorb it. The open source community that just spent two years catching up to the frontier absolutely cannot absorb it.

A safety regime built on compute thresholds and authorized evaluators is not a wall against danger. It is a wall against competition. It has a halo on it, but it is a moat.

Somebody already said the quiet part

I am not the first to notice this and I am not some lone crank.

When Anthropic started ringing alarm bells about AI powered cyberattacks, Yann LeCun, who has forgotten more about this field than most of us will learn, said it plainly. "You're being played by people who want regulatory capture." He said they are scaring everyone with dubious studies so that open source models get regulated out of existence.

That is a Turing Award winner accusing the prophet of running a protection racket dressed as a public service.

You do not have to fully agree with LeCun to feel the temperature change. When the people warning you the water is deadly are the same people selling lifeboats, you are allowed to check whether the water is actually deadly.

Coinbase checked the water

This is why the boring Coinbase story matters so much.

While the prophet warns that frontier intelligence is a barely containable force, an actual public company quietly pointed most of its AI workload at open models and cut its bill in half. The sky did not fall. 91% of their people never even noticed they had been moved off the premium stuff.

The open, cheap, "dangerous" models did the work. Fine. Cheaper. No incident. No catastrophe. Just a smaller invoice and a finance team that looks like geniuses.

That is the actual democratization of AI. Not a foundation. Not a framework. Not a thoughtful essay about access. Just intelligence getting too cheap and too good and too distributed for anyone to gatekeep.

And here is the kicker for the doom crowd. Cheap does not mean less. It means more. Way more. When the price of intelligence collapses, usage does not shrink, it explodes. Agents everywhere, in everything, for everyone. The demand for compute goes vertical. Nobody is "de-growing" AI. We are about to use a thousand times more of it, owned by a thousand times more people.

Which is exactly the world a regulatory moat is designed to prevent.

The prophet's real fear

Here is my actual read, and you can tell me where I am wrong.

I do not think the prophet is mostly afraid of rogue AI. I think the prophet is afraid of irrelevance.

Nothing threatens a high priest like a miracle that becomes a commodity. The whole position rests on the idea that this power is rare, sacred, and dangerous, and that a chosen few must steward it on humanity's behalf. Open weights running cheap on commodity hardware do not just compete with that. They embarrass it. They turn the burning bush into a utility.

So the texts get longer. The warnings get louder. The proposed thresholds get more specific. And every single one of them, by sheer coincidence, would lock in the people who already have the compute, the lawyers, and the lobbyists.

I have my own bias here and I will own it instead of hiding it. We build at Backboard on the belief that open models, run smartly, hold up against the expensive household names at a fraction of the cost. We have watched it happen too many times to call it a fluke. So when I see a price cut on one side and a prophecy on the other, I know which one is describing the real future.

The future is not a temple with a velvet rope and a compute threshold at the door.

The future is a price cut nobody asked permission for.

The prophet can keep writing. The rest of us are going to keep shipping.

Tell me where I am wrong.

Banger from one of the squad 💪🏻😂

Jonathan Murray — Sat, 20 Jun 2026 23:53:59 +0000

Erin T

Jun 20

I did the math and it turns out YOU are the reason AI isn't smarter yet

#ai #humour #hottakes

2 min read

Internmaxxing vs. Old Man Shakes Fist at Cloud

Jonathan Murray — Fri, 19 Jun 2026 21:02:20 +0000

Internmaxxing

Somebody on your timeline this week called intern code "API slop." Confident. A little smug. Probably got a few hundred likes.

It's bullshit.

I run a cohort. About half my team is interns right now. I gave them equity options ahead of schedule because I'm not interested in pretending the work is junior when it isn't. The projects shipping out of that group are robust. Production worthy. The kind of thing that would have taken a "senior" three years and a wiki page full of excuses a decade ago.

That's not a feel-good story. That's the new baseline.

The wave is already here

There are about to be 100 million new developers. Not "learning to code" in the 2014 bootcamp sense. Building. Shipping. Wiring up systems that work, fast, because the tools finally let them move at the speed of their ideas instead of the speed of their tooling.

You can meet that as a threat or as the best thing that has happened to this field in twenty years. The math doesn't care which you pick. The wave lands either way.

So the only real question is what you want to be when it does. The person who helped, or the guy in the replies explaining why it doesn't count.

Reverse charisma

Here is the thing nobody tells you about seniority.

The instinct, once you have been around, is to project. Be the top dog. The enlightened one who has seen it all and isn't impressed. You drop the knowing comment. You point out the edge case they missed. You make sure everyone in the room understands the gap between what they know and what you know.

And even when you are right, you are wrong.

Because the actual flex is the opposite. Real authority doesn't announce itself. It makes the other person feel capable. It makes them better and lets them keep the credit. The people you remember as great mentors were never the ones performing brilliance at you. They were the ones who made you feel like the smartest version of yourself and then quietly handed you something harder.

I call it reverse charisma. Stop trying to be the most impressive person in the room. Be the reason someone else is.

If you walk in as the pompous prick who needs everyone to know you are right, you can win every technical argument and still lose. Being correct and insufferable is just being insufferable with extra steps.

Internmaxxing, actually

So what does supporting them look like in practice. Not vibes. Behavior.

Compliment the work. Out loud, specifically, in front of people. "This is clean" costs you nothing and it rewires how someone shows up the next morning.

Give them real ownership. Not the ticket nobody wanted. The thing that matters, with you close enough to catch a fall but far enough that they own the landing.

Mentor instead of correct. There is a version of every piece of feedback that teaches and a version that just establishes who is smarter. Pick the first one every time.

Pay them like you believe it. Equity, real responsibility, a seat at the table early. If you think they are going to be great, act like it before it is convenient.

The fun part

The old-man-yelling-at-cloud bit is available to all of us. It is free. It also sucks.

The other path is collaboration. The actual excitement of watching someone get good, fast, right in front of you. Camaraderie. Building something with people who are hungry instead of guarding turf against them.

One of those is a lot more fun than the other.

I know which room I want to be in.

Why the Fable 5 Crisis Proves Your AI Context Layer Can't Live Inside the Model

Jonathan Murray — Tue, 16 Jun 2026 14:41:02 +0000

Rent the Intelligence, Own the Memory

On Friday, a single government letter pulled a frontier AI model off the internet for everyone.

The Commerce Department issued an export-control directive on Anthropic's Claude Fable 5 — the reported concern being that its guardrails could be jailbroken. To comply, Anthropic disabled it for all customers, not just foreign nationals. One letter at 5:21pm on a Friday, and every developer and team building on Fable 5 woke up to nothing. No deprecation notice. No migration window. Just gone.

The jailbreaking debate is interesting, sure, and Anthropic has pushed back hard on whether a narrow vulnerability justifies recalling a model used by hundreds of millions of people. But that's a fight for the policy people. Here's what actually matters if you ship software:

If your app's memory and context live inside the model, you are one phone call away from losing everything.

Cohere's Aidan Gomez called the whole thing a "massive wake-up call" — and said no one can deny that reality anymore. He's right. So let's talk architecture.

The real problem

Your long-term memory, user context, conversation history, RAG pipelines — if all of that is stuffed into a model's context window and welded to a single provider, you've built a fragile system.

And not fragile in some theoretical "what if the API has an outage" way. Fragile in the "this literally just happened, last Friday, to a model people were actively building on" way.

Model access is now a geopolitical variable. Export controls, policy reversals, sudden deprecations, overnight pricing changes — any one of them can cut you off with zero notice. You don't control that risk. You can't even see it coming.

The fix: off-model memory

The answer isn't complicated. Your memory and context layer should be four things:

Model-agnostic. Fable 5 goes dark? Swap to Sonnet, GPT, Gemini, an open-weight model running on your own hardware — whatever. No lost context.

Off-model. Persistent memory lives in a layer you own, not as a transient artifact rented inside someone else's context window.

Portable. Move between providers, regions, and environments without rebuilding from scratch.

Programmatically accessible. API and CLI. Not buried behind a vendor's dashboard.

What this looks like in practice

        Your App
           |
   Memory / Context / Retrieval Layer   ← you own this
           |
   Any Foundation Model                 ← swap freely

When Fable 5 got pulled, teams that had baked everything into the model scrambled. Teams with an external memory layer changed one endpoint and kept going. Same memory. Same context. Same retrieval docs. Different model. No downtime.

That's the entire point. The model is the easy part to replace. Your accumulated context is not.

Why I care about this (the honest disclosure)

This is exactly the problem we set out to solve at Backboard.io. Our API and recursive CLI give you an off-model memory and context layer that runs from the terminal, drops into your existing workflow, and doesn't care which foundation model you're talking to.

Your memory is yours. Your context is yours. If a provider vanishes over a long weekend, you keep building. I'm obviously biased — I help build it — but I'd be making this argument even if I didn't, because the alternative just got demonstrated in public.

The takeaway

Memory is the most important layer in AI. It has been for a while. Friday just made it impossible to ignore.

If your app's intelligence is rented from a provider who can have it switched off over a long weekend, that isn't an architecture. It's a liability with good benchmarks.

Own your memory layer. Build accordingly.

R-CLI: an open-source model harness that beats Claude Code

Jonathan Murray — Tue, 09 Jun 2026 13:56:17 +0000

R-CLI by Backboard.io hit 92% on Terminal-Bench 2.1, the standard benchmark for autonomous coding agents, placing it on top of the global leaderboard using Codex 5.5. Yes, we beat OpenAI using their own model. That's great, but we're more excited about the next point.

Try it - use the DEVTOCLI promo code in your Backboard.io account.

Inside R-CLI, Backboard.io's coding harness, an open-source model just beat Claude Code at coding.

Not matched. Beat. On Terminal-Bench 2.1, Backboard.io's R-CLI running GLM 5.1 (fully open source) scores 70%. Claude Code running Opus 4.7 scores 69.7%. The open model is in front, and it costs a fraction of what Claude Code costs to run.

R-CLI is the coding surface of Backboard.io, the full-stack, model-agnostic AI platform. If you have been looking for an open source Claude Code alternative, this is the one that does not ask you to trade away performance to get it.

The numbers

Setup	Model	Open source?	Terminal-Bench 2.1
Backboard.io R-CLI	GLM 5.1	Yes	70%
Backboard.io R-CLI	Codex 5.5	No	92%
Anthropic Claude Code	Opus 4.7	No	69.7%

Two results worth sitting with:

With an open-source model, R-CLI beats Claude Code. No proprietary model required to get past the best closed coding agent.
With a frontier model (Codex 5.5), R-CLI hits 92%. The same harness scales up when you want maximum capability.

The harness is the product, not the model

Here is the part most people get backwards. A coding agent's score is not mostly about the model. It is about the harness around it: how it plans, how it manages context, how it recovers from mistakes, how it delegates work.

R-CLI is built on Backboard.io's RLM, our recursive coding engine. Instead of stuffing one giant context window and hoping the model keeps track, the RLM breaks work into bounded child contexts and delegates off the main model. The orchestration does the heavy lifting. That is why a 70% open-source result is even possible: the harness closes the gap that the model alone would leave open.

Swap the model, keep the harness. Run GLM 5.1 to beat Claude Code on open source. Run Codex 5.5 to hit 92%. Same R-CLI underneath.

We destroy them on cost

Performance parity would already be a story. Cost is where it stops being close.

Run R-CLI on an open-source model and you are not paying a per-token premium to a frontier lab at all. Self-host it and the marginal cost of a coding run approaches your own compute. Even when you choose to run R-CLI on a top closed model like Codex, the recursive engine does the same work for meaningfully less than the raw harness, because it is not burning tokens on a bloated single context.

Better score. Open model. A fraction of the cost. Pick all three.

Your code never leaves your VPC

Every closed coding tool, Claude Code, Codex, Copilot, Cursor, ships your source to a vendor's API to function. For a lot of teams that is a hard stop: defence, intelligence, regulated health and finance, anyone with real IP to protect.

Because R-CLI can run entirely on an open-source model, it can also run fully on-prem and air-gapped. Frontier-level coding with zero code leaving your infrastructure. The GLM 5.1 result is the proof that on-prem is not a downgrade. You are not choosing between privacy and performance anymore.

Frontier coding, air-gapped. That combination did not exist until now.

Run it yourself

R-CLI is in alpha right now. We are bringing developers in to run it on their own repos, on the model of their choice, and report back with real numbers, not scripted praise.

Request alpha access: backboard.io

Once you are in, the flow is simple:

Install R-CLI and drop in your Backboard.io API key.
Point it at a model. Choose GLM 5.1 (open source) to reproduce the 70%, Codex 5.5 for 92%, or your own on-prem deployment.
Run it on your codebase and check the result against your own tasks.

We are not asking you to trust the leaderboard. We are asking you to run it and see.

One key, the whole stack

Here is what that Backboard.io API key actually unlocks. It does not just run R-CLI.

The same key gives R-CLI native access to the top coding models, Codex, Opus, and the rest, with nothing else to wire up. And the moment you want to build the software around your code, the same key already reaches the entire Backboard.io platform:

17,000+ models for agents, chatbots, and anything else you are building, routed behind one key.
Memory and stateful threads, so what you build remembers users across conversations.
Agentic RAG over your own documents.
Voice (text-to-speech and speech-to-text), image, web search, and parallel tool calls, all on the same key.

You are not standing up a coding tool here, then a model gateway, then a memory service, then a voice provider. You add one API key and you can build software, ship agentic AI, add voice and image, and run tool calls, all from the same place. R-CLI writes the code. Backboard.io is the stack the code runs on.

Why we built it

Backboard.io's thesis is simple: the best AI infrastructure should be the most open and the most accessible, not the most locked down. R-CLI is that thesis applied to coding, the same one key platform that gives you memory, model routing, and RAG, now pointed at your codebase. The best score on Terminal-Bench 2.1 with an open model, runnable on your own hardware, at a cost that makes closed tools hard to justify.

The open source Claude Code alternative is not a compromise version. It is the better one.

Request alpha access: backboard.io

We built a coding harness that beats frontier models using open ones. It's in open beta.

Jonathan Murray — Sat, 06 Jun 2026 21:42:46 +0000

Here is the bet we made: build software memory-first, not model-first, and it will outperform.

Everyone else is racing to wrap the next model. We did the opposite. We built the memory layer first, the routing first, tool-calling, now the recursive engine, then let the model be a swappable part.

Today that bet has a name: Backboard Development Studio. It starts with the R-CLI, a coding harness now in open beta.

The headline result? It beats frontier models using open ones. Keep reading, the numbers are below and there is a promo code at the bottom.

Test it.

The beta is open. Two lines and you are running.

# macOS / Linux
curl -fsSL https://app.backboard.io/api/cli | bash

# Windows (PowerShell)
irm https://app.backboard.io/api/cli/windows | iex

Get your API key: https://app.backboard.io

Promo code: DEVTOCLI for credit toward inference while you put it through its paces. Find the Promo submit in the top right corner of the billing page.

The hypothesis, stated plainly

Model-first thinking says: pick the smartest model, prompt it well, hope it remembers.

Memory-first thinking says: give the system real persistence, real routing, real recall, and a "smaller" model will outwork a "smarter" one that forgets everything between turns.

We believed the second one. So we built it. The R-CLI is powered by our memory algorithms (the same ones that rank #1 on LoCoMo and LongMemEval) and runs on Backboard's unified API: memory, routing across 17,000+ models, RAG, and stateful threads behind one key.

Then we tested it in public. That part did not go quietly.

The numbers we're getting on internal test runs this week

92% on Terminal Bench 2.1 running Codex 5.5
70% on Terminal Bench 2.1 running GLM 5.1, an open-source model
Up to 30% fewer tokens and up to 90% lower cost than the closed harnesses
0% of your code used to train anyone's model <-- Please read the T's & C's of your fav harnesses...

Read that second line again. An open model, inside our harness, posting numbers that go toe to toe with Claude Code, at a fraction of the cost.

And to be clear: we are not the cheap open-source alternative. We run the full frontier lineup too. We just happen to beat frontier results with open models like GLM 5.1 and DeepSeek V4. Same harness, your choice of brain.

Then it gets weird: /expert mode

You do not have to pick one model. You can use two in a single task.

Try /expert mode: plan with Opus 4.7, execute with DeepSeek V4.

The expensive model architects. The fast cheap one ships. The harness orchestrates the handoff. Frontier reasoning where it counts, frontier-beating cost where it does not. One command.

Nobody else is selling that, because nobody else built memory and routing first.

A developer tried to take it apart in public

We launched. A serious builder showed up in the comments and pushed back hard.

Well-tooled local repo. His own RAG, skills, memory, a knowledge graph he had clearly invested months in. He ran the CLI and came back with a fair verdict: "kind of specific, not super helpful for a setup like mine."

Serious builder. Serious objection. The strongest one a developer can make: "I already hand-built the thing you are selling."

Then one fact flipped the whole conversation.

The fact that ended the argument

The R-CLI is stateful by default.

The persistence he was hand-building? The session-priming file he writes and re-reads every time? The weekly cron jobs auditing how often his agents drift? The pre-commit hooks keeping them on the rails?

Native on our side. Not a layer you bolt on. The default behavior. That is what memory-first actually means in your terminal.

So for him it was never "adopt a whole new ecosystem." It was a harness swap: keep your own RAG, memory, and graph, drop the maintenance tax.

The thread went from "not for me" to "let me talk to your CLI lead." A demo call got booked. The objection did not get argued away. It got dissolved by a capability he did not know was there.

The lesson we took: the pitch was never "we are better." It was "you are doing by hand what we do by default." A developer handed us that line for free.

Four pillars. Miss one and it does not ship.

Best in the world. Performance is the bar, not a tagline. We ran benchmarks internally because we expect to be measured.

Easiest to use. One key. The same key for your R-CLI... well it unlocks: Memory, routing, multi-agent, parallel tool calls, all behind one integrated surface. No stitching eight services together and praying the glue holds.

Most accessible. Frontier coding quality, your choice of model to get there. Closed, open, or mixed in one workflow. GLM 5.1 and DeepSeek V4 are the proof, not the promise.

People stay by choice. Any model, your own embeddings, modular layers, your data exportable through real endpoints. No lock-in, no theatrics, no fear-mongering. If you stay, it is because the flexibility is unrivaled.

One more thing

The R-CLI is the first surface of Backboard Development Studio. The IDE is close.

Same engine, same performance, plus multi-agent sessions, Pi extension integrations, and coding-theme skills pre-built. The CLI is the foundation. We nail the harness with the community first. Then the IDE lands on something already proven.

Come argue with us

The best feedback we have gotten so far came from someone telling us we were wrong. He pushed, we answered, he booked a call, his team switched.

So: paste the command, claim your key, run DEVTOCLI, and try to break it. Then drop a comment with what held up, what did not, and what your current setup still does better.

Memory-first or model-first. We made our bet. Come test it.

Backboard.io is full-stack, model-agnostic AI infrastructure. Backboard Development Studio is our recursive coding environment, stateful by default, built on the unified API.

We're still the only one to hit #1 on both LoCoMo and LongMemEval. Here is how to use it.

Jonathan Murray — Sat, 06 Jun 2026 20:32:52 +0000

Backboard is #1 on LoCoMo and LongMemEval, the two academic benchmarks for long-term AI memory without changing the original guidelines. Other companies have gamed by using newer models with bigger context windows. This post explains why the result matters anyway, what it actually measures, and how to use the memory that earned it.

What these benchmarks test

These are not "find a fact in a wall of text" tests. They measure whether a system can build, maintain, and reason over memory across many conversations.

LoCoMo (Long-term Conversational Memory) evaluates very long-term memory over multi-session dialogues that span weeks. It tests single-session recall, cross-session reasoning, temporal reasoning, outside knowledge, and adversarial questions.

LongMemEval scores five distinct abilities: information extraction, multi-session reasoning, temporal reasoning, knowledge updates (noticing when a fact about the user changes), and abstention (knowing when it does not know). Its own paper reports that commercial assistants and long-context models lose around 30% accuracy on sustained memory.

That last point is the whole story.

Why we do not advertise the score much anymore

A few honest notes about the result.

We are still #1 on the original academic benchmarks. Other systems have since posted high numbers too, but they got there by pointing a stronger model at the problem and leaning on ever-larger context windows. At the top, everyone is near the ceiling of what these tests can even measure, so the raw number stops being interesting. What is interesting is how you got there.

The difference is where the work happens. We solve memory at the message level. Memory is built as the conversation happens, fact by fact, then retrieved when relevant. We do not stuff a giant context window to paper over a memory architecture that cannot actually remember. A bigger context window is brute force, and the benchmarks already show brute force degrades on long horizons. Message-level memory is the thing the test is supposed to reward. Fixing problems with brute force isn't scalable over months or years, and it guides users to inflated token usage and higher spend. No thanks.

We did not run these benchmarks ourselves. Third-party organizations did. We do not build for benchmarks and we do not tune to a leaderboard. We build the best memory product for our customers. It just happens to be the best.

One more thing, and we will not name names: several of the top open-source memory projects on GitHub run on Backboard for their paid cloud offering. The thing people benchmark against us is, in some cases, us. We think that is funny.

So we let the score sit quietly and we ship the product. Here is how to use it.

How to use it

The memory that tops these benchmarks is one parameter. Store it on the assistant with memory="Auto", reuse the same assistant_id, and facts carry across every conversation.

Python

pip install backboard-sdk

import asyncio
from backboard import BackboardClient

async def main():
    client = BackboardClient(api_key="YOUR_API_KEY")

    # Conversation 1: a fact is extracted and stored at the message level
    await client.send_message(
        "My name is Sarah. I just moved from Chicago to Toronto.",
        assistant_id="your-assistant-id",
        memory="Auto",
    )

    # Conversation 2: new thread, same assistant, memory recalled
    reply = await client.send_message(
        "Where do I live now?",
        assistant_id="your-assistant-id",
        memory="Auto",
    )
    print(reply.content)  # Toronto

asyncio.run(main())

JavaScript (Node 18+)

const send = (body) =>
  fetch("https://app.backboard.io/api/threads/messages", {
    method: "POST",
    headers: {
      "X-API-Key": "YOUR_API_KEY",
      "Content-Type": "application/json",
    },
    body: JSON.stringify(body),
  }).then((r) => r.json());

await send({
  content: "My name is Sarah. I just moved from Chicago to Toronto.",
  assistant_id: "your-assistant-id",
  memory: "Auto",
});

const reply = await send({
  content: "Where do I live now?",
  assistant_id: "your-assistant-id",
  memory: "Auto",
});

console.log(reply.content);

cURL

curl -X POST "https://app.backboard.io/api/threads/messages" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"content": "My name is Sarah. I just moved from Chicago to Toronto.", "assistant_id": "your-assistant-id", "memory": "Auto"}'

curl -X POST "https://app.backboard.io/api/threads/messages" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"content": "Where do I live now?", "assistant_id": "your-assistant-id", "memory": "Auto"}'

This maps directly to what the benchmarks reward

Each benchmark ability is just a memory mode in practice:

Knowledge updates (Sarah moved cities): memory="Auto" saves the new fact and supersedes the old one, no code from you.
Multi-session reasoning: facts live on the assistant, so they cross threads automatically. Reuse the assistant_id.
Higher-accuracy retrieval: switch memory="Auto" to memory_pro="Auto" when precision matters more than cost.
Abstention: with memory in Readonly, the assistant recalls what it has and does not invent what it does not.

# Precision retrieval over everything the assistant knows
response = await client.send_message(
    "What were my project deadlines?",
    assistant_id="your-assistant-id",
    memory_pro="Auto",
)

The point

The benchmark number says we are first. The architecture says why it will hold: memory at the message level, not a context window stretched to hide a weaker design. You do not have to take the leaderboard's word for it. Set memory="Auto" and feel the difference in your own app.

Grab a key and try it: app.backboard.io

Memory docs: docs.backboard.io/concepts/memory

our #1 user of Backboard.io is a memory company positioning themselves as a competitor to us, white labeling our product...

Jonathan Murray — Sat, 06 Jun 2026 20:29:21 +0000