Systems got C·The web got JavaScript·Machine learning got Python
Systems got C
The web got JavaScript
Machine learning got Python
AI orchestration have Weft
A programming language made for what will kill AI agents
Open source · Free to try · Join the Discord
What you can try today is a proof of concept. The MVP is on its way to global release
Not ready to sign up? Follow the build
No spam. Occasional updates on what I ship and what is coming.
Our founder red-teamed AI since davinci for
OpenAI
Anthropic
METR
Amazon AGIThis is Weft, click around
Our AI (Tangle) wrote the code, the graph is for you. Same program synchronized
Loading playground...
built from one prompt, in under a minute
Same prompt · same AI model
20x faster than existing coding assistants
Tangle with Weft vs Claude Code with Python
WeaveMind · you describe, it buildsA graph you can read, in plain language. No terminal, no code to debug
Claude Code · PythonStill going. Commands, files, an error to read. You can't tell where it is.
Proof-of-concept recording, Sonnet 4.6 era. We'll re-record when the MVP is out.
Orchestration always beats agents
The right computation at every step
An agent makes one model do the whole job in one context
Break it into scoped steps and you win four ways
Who decides what happens
An agent is open-ended, no fixed shape
A fixed structure, set before it runs
An agent is open-ended, anything can happen. Here the work runs to a structure that's set before it starts, so you know what it will do
Safer
Safer
An agent is open-ended, anything can happen. Here the work runs to a structure that’s set before it starts, so you know what it will do.
An agent · open-ended
A fixed structure
Smarter
Scoped to its job, the model isn’t distracted by everything else the task touched, so it does it better.
One agent juggling everything
Each piece handed just its part
Faster
An agent is one worker doing everything in turn. A graph runs the pieces side by side, with no single bottleneck.
Cheaper
An agent re-reads the whole conversation every time it acts, and you pay for it each time. Each piece here pays once.
People tried, the tools fought them
So why isn’t everyone building orchestrations?
Traditional
languages
None was made for this
You fight the language
Visual flow
builders
Locked to pre-made blocks
Tangle
+ Weft
Built for orchestration
Tangle + Weft
Built for orchestration
Traditional languages
You fight the language
Visual flow builders
Locked to pre-made blocks
The agent’s one edge was always speed to build: nothing to set up, just prompt it Tangle build so fast in Weft that building and running orchestrations beats agents
build + run, end to end, beats the agent in most real cases
Reliable systems, from unpredictable parts
You decide how tightly each component is contained
Unconstrained
acts freely, less predictable, fast to build
Fully contained
output bounded and checked, predictable
Prototype fast with everything unconstrained, then contain the parts that need to be reliable, without losing the intelligence
Who this is for
Hobbyists & small businesses
Build the things that make your life easier
Automate your inbox, your invoices, your community. You know your tools and your process: describe what you need and ship the same day
Vertical-AI & enterprises
Robust systems running at scale
You bring the domain expertise. We're the backbone you build on, and we embed alongside your team. White-label it, run it on your infrastructure, audit every step
Lead
Subject
Message
Native human in the loop
When the AI needs a human, it asks
Weft has a browser extension built right in. When it needs you it just waits, for days if it has to, free the whole time, then picks up the second you’re back
Why a new language
The same system, in Python vs Weft
import anthropic, psycopg2, smtplib, os, json
from email.mime.text import MIMEText
client = anthropic.Anthropic(api_key=os.environ["KEY"])
conn = psycopg2.connect(os.environ["DB_URL"])
# Query leads from database...
cur = conn.cursor()
cur.execute("SELECT * FROM leads WHERE ...")
leads = cur.fetchall()
# Qualify each lead with LLM...
response = client.messages.create(
model="claude-opus-4-20250514",
max_tokens=1024,
messages=[{"role": "user", "content": ...}]
)
# Parse JSON, validate, set up SMTP,
# format email, handle errors, send...
# (80+ more lines)db = PostgresDatabase
qualify = LlmInference { parseJson: true }
review = HumanQuery "Review Email"
send = EmailSend
qualify.prompt = db.rows
review.body = qualify.draft
send.body = review.bodydatabase + LLM + human review + email, 7 lines
Same system, a fraction of the code. The AI writes it in a fraction of the tokens, so it builds faster and gets more right
And the compiler can read the whole thing and reason about it, so it catches a broken system before it runs
Ready-made nodes
Weft
As a language it wires nodes together
As a framework it lets you build them
Your own code
A dynamic vocabulary
The vocabulary is yours to define
If you build with nodes, Weft is a language. If you build the nodes, it's a framework that makes wrapping your own code into one short and easy
One person wraps something hard once, and everyone else just drops it in: yours, mine, the whole community's. And since it's a framework underneath, you can open any node and bend it to your needs. You're never stuck
Recursively Foldable
A hundred nodes still look like five
Any group of nodes folds into one, with its own inputs and outputs. Groups nest in groups. You see five boxes, open the one you care about, the rest stays folded
Visual builders turn to spaghetti past twenty nodes because they can't fold. Weft can, so it stays readable no matter how big it gets
Coming soon in the MVP
What’s landing next
Built on top of Rust
Real code, not a slow graph
The AI writes a high-level graph. Weft turns it into native Rust, so it runs at full speed instead of crawling through an interpreter the way the old visual tools do
You run it with one command. It starts itself, runs as a live service, and plugs into the rest of your system
Built on top of Kubernetes
Every node brings its own infrastructure
A database node knows it needs a database. When you run, Weft spins up everything your nodes need, on its own, and tears it all down when you’re done
No YAML, no DevOps. It runs on your machine, your cloud, or ours, the same way every time
provisioned automatically
Agents that talk to each other
A swarm you can watch in real time
Agents run as nodes, side by side, and talk over a shared bus. You see every message they send each other, live, as it flows
Every exchange is logged and replayable, so nothing is a black box
Pricing
Early pricing while we test the waters. Expect it to change before launch
Usage
At cost + 60%
Pay as you go, no commitment
- All primitives
- AI builder (Tangle)
- Human-in-the-loop
- 500 MB storage
- $0.01/execution
Starter
$20/mo
At cost + 35% · $20 credits/mo
- Everything in Usage
- Lower markup (35%)
- Rolling credits
- 5 GB storage
- $0.001/execution
- Infrastructure access
Builder
$100/mo
At cost + 20% · $100 credits/mo
- Everything in Starter
- Lowest markup (20%)
- 25 GB storage
- $0.0001/execution
- Priority support
Enterprise
Custom
For agencies and large teams
- Everything in Builder
- White-label deployment
- Custom primitives
- Dedicated support & SLA
I spent three years breaking AI for a living. Red teaming for OpenAI and Anthropic, evaluating frontier models at METR, running a red-teaming startup in Paris. I was one of the first people outside OpenAI to ever touch GPT-4, and I won the first worldwide jailbreak competition with a single prompt that broke every model they put up.
So I know how these systems fail. The fixes are almost always simple: add a check, improve the prompt, put a human in the loop. But every fix is more plumbing, and I watched small teams burn hundreds of thousands of dollars just keeping that plumbing alive.
I don't think the answer is a smarter agent. I think it's orchestration. Code has always been orchestration, of numbers and strings. Now we can orchestrate reasoning, and nobody has built the language for it yet. That's the bet. You build a shape, you run the shape, and it holds even when the model inside it slips. Every era of computing got the language it deserved. I'm convinced this one needs Weft, and almost no one is looking here. That's exactly why I am.
As flexible as an agent, as reliable as code
Enterprise plans available · Contact us
