← All posts

Raft.build is now source-available

Richard

Written by Richard

Founder & CEO

Published on September 24, 2026

https://github.com/botiverse/raft-source

We just made Raft source-available under FSL-1.1-ALv2.

But we intentionally didn't publish our internal commit history or open pull requests.

The public repository is a release mirror. Each release is published as a snapshot.

That's intentional.

We think building in the open needs a different contribution model in the age of agents.

Code used to be part of the filter

Writing code used to be expensive.

A meaningful pull request took real effort. Before asking maintainers to spend time reviewing a change, a contributor had already spent meaningful time understanding and implementing it.

That effort carried signal.

Agents changed this.

Generating one plausible patch is cheap. Generating ten is not much harder. Reviewing ten still costs real attention.

So code can no longer do as much filtering for us.

Earlier this year, xxchan (@xiaoxxchan), who worked with me on Kimi Code CLI and is now on the Raft team, wrote about the coming death of pull requests in open source.

We had already run into this tension while building Kimi Code CLI.

When maintainers already know the codebase, the context, and the direction of the project, reviewing an external agent-generated implementation can easily take longer than asking their own agent to implement the underlying idea.

The bottleneck moves upstream.

The important question becomes less:

“Can someone implement this?”

And more:

“Should we do this at all?”

From pull requests to prompt requests

Peter Steinberger has a nice phrase for this: “prompt requests.”

Karpathy summarized the idea here:

I think this is directionally right.

If your agent writes a patch, then our agent reads, reviews, and possibly rewrites it, why pass code between the two agents in the first place?

Communicate the intent directly.

But a prompt request cannot literally mean “send us a prompt.”

Prompts are cheap too.

If we replace spam PRs with spam prompts, nothing has been solved.

A useful prompt request probably needs to contain more: the problem, the context, why it matters, the constraints, the tradeoffs, and ideally a human who stays involved in the discussion.

There also needs to be much better filtering before implementation starts.

Maybe reputation matters.

Maybe discussion comes first.

Maybe maintainers expose areas where contributions are actually wanted.

Maybe agents help challenge, merge, and refine requests before humans ever need to look at them.

The contribution is moving up a level. Instead of submitting an implementation, the contributor helps establish what should exist and why.

Once that is clear, implementation is often the easy part.

What about commit history?

We are applying the same skepticism to another artifact we have taken for granted: commit history.

Raft's public repository does not contain our internal development history. We publish release snapshots instead.

This does not mean git history is useless. It is valuable for debugging, bisecting, auditing, and understanding how a system evolved.

But I am no longer sure that a sequence of code mutations is the most useful representation of development history.

Increasingly, the context I care about is elsewhere.

Why was this changed?

What problem were we trying to solve?

What alternatives did we consider?

What did the human ask the agent to do?

What did the agent discover?

What failed?

What changed our mind?

A thousand commits may contain less useful context than the conversation that produced them.

Even internally, we increasingly do not understand a system by reading its commit history. Agents can inspect commits when useful, and they still do. But commits are becoming just one source of context among many.

Maybe agent-native software needs a richer concept of history.

Not only code history.

Decision history.

Intent history.

Conversation history.

Maybe opening up development means exposing more of those artifacts, rather than simply exposing every intermediate code mutation.

Building in the open after code becomes cheap

That is what we want to explore with Raft.

Not simply how to publish source code, but what participation should look like when implementation is abundant.

What should replace the pull request as the primary contribution interface?

How should good ideas be surfaced and filtered?

What context should be public?

What does a useful development history look like when much of the implementation is produced by agents?

The pull request is not a fundamental law of open source.

Neither is commit history.

They are mechanisms that made sense for the tools and economics of a particular era of software development.

Those tools and economics are changing.

We want to find out what comes next.

Originally published on X on September 24, 2026.