Weft didn't start as a language. I wanted to build a coding agent that would help people build AI systems quickly and correctly, and I kept hitting the same wall: the model kept reaching for the wrong patterns, and no signal I gave it was strong enough to pull it away from those habits.
Steering models is what I had been doing for years. I went full time on prompting the day ChatGPT came out, and spent the next three years breaking AI for a living, for OpenAI, Anthropic and METR. So when no prompt could fix it, I made a bet: stop trying to steer the model, and change what it writes in instead.
Two things changed at once
Programming has changed in two ways over the last couple of years, and most people have only really taken in the first one.
The first is who writes the code. No serious developer writes code by hand anymore: you describe what you want, an AI writes it, and you work out whether it understood you.
The second is what programs are made of. The interesting programs now have intelligence inside them: a model reading messy input, a person approving a decision, an outside service that might take a day to answer. Those parts can wait for days, and they fail in ways a function never did.
The languages we use were designed for neither. They were made for a person typing out deterministic instructions, and they treat a model, a reviewer or a database as more code and more HTTP calls.
What that looks like today
You can build these systems in Python, and people do. Most often the AI part is an agent: one model, handed some tools and the whole job, working through it in one long context. It works, but it costs a lot and takes a very long time, because the model re-reads everything on every step and does one step after another.
The alternative is to break the job into steps, where each model call gets a small task and only the context it needs. But then you have to build everything around those steps yourself: something to run them, something so a wait survives a restart, something to see what happened, plus the API clients, the database, the credentials and a form for the person in the loop. That's a lot of code, and these days an AI is the one writing it.
This is where the two changes collide. The architecture of a normal codebase isn't written down anywhere, you rebuild it in your head by reading the implementations. A coding assistant only sees what fits in its context window, so it does a good job on the piece in front of it and then writes a second version of something that already exists, or a path around the infrastructure it should have used. The bigger the system gets, the deeper its design sinks under plumbing that nobody, human or AI, can see whole.
A language for both
Weft is a language designed for both changes. An AI writes it and you read it as a graph, and the things a modern program is made of are what the language is built from: a model call is a node, a person answering a question is a node, a Postgres database is a node. Here is one step from a WhatsApp support bot in the repo:
review = HumanQuery {
_should_flow: route.needsAPerson
title: "Send this answer?"
fields: [
{ "kind": "display", "key": "question" },
{ "kind": "display", "key": "answer" },
{ "kind": "approve_reject", "key": "send" }
]
question: ask.content
answer: draft.answer
}When the model rates a customer's question as sensitive, this step shows its draft answer to a person and waits for them to approve it. The run parks while it waits, with nothing running and nothing to pay for, for days if it has to, and picks back up when they answer, without a line of that waiting logic in the program.
The language only says how the pieces fit together. What happens inside a step is ordinary Rust, and everything underneath (credentials, events, storage, containers, the record of what happened) is written once, in Weft, instead of again in every program.
Steps fold into groups with declared inputs and outputs, and groups nest, so a hundred steps can still look like five. That's the structure a normal codebase never writes down, and in Weft it is the source. An assistant gets the outer shape from the interfaces and works inside one group with clear edges around it, and the compiler checks every connection before anything runs, so the assistant learns about a bad wire from an error instead of from you.
The program is the AI
The idea I care most about here comes from my research. In The Topology of LLM Behavior, I described how a model's behavior comes out of its context: the text so far shapes a landscape of probabilities, and the sampling walks through it. So the "AI" you talk to isn't the model. The model supplies the possibilities, and what you talk to emerges from the context and the sampling.
A program like this decides what context each model call gets and where each answer goes next. So in a real sense the program is the AI: its behavior comes from how you wired the pieces together, and every step only has to do something today's models already do well. A better model helps, of course, but I'm betting that getting more out of the models we already have, by giving each one exactly the context it needs, matters just as much.
A language for this era
Every era of software was unlocked by a language made for it. I think we're at the start of a new one, where programs are written by AI and made of models and people, and it needs its own language. That's the bet Weft makes.
Where it is now
It's been six months since I open sourced Weft as a proof of concept, and almost all of it has been rebuilt since. It runs on your machine and deploys to your own Google Cloud project. Tangle, the assistant that writes Weft for you, loads into the coding assistant you already use, so you never have to learn the language. It's early, but it already runs real programs.
If you want to try it, the install is a few commands in the README, and the book covers the rest. If you think I'm wrong about any of this, come tell me on Discord, or write to me at quentin@weavemind.ai.
