Our founder red-teamed AI since davinci for
OpenAI
Anthropic
METR
Amazon AGI▶ Meet Tangle
On the left, a real request for a WhatsApp bot that turns your voice notes into text. On the right, the program Tangle built for it, already running.
From an idea to a deployed product, without you steering each step.
30min
for Tangle to build, often from a single prompt, a program the best AI models take tens of hours to write on their own.
Tells you the plan first
In a sentence or two it tells you which steps the program will have, and if there is a real choice to make, it asks you before building.
Writes expert prompts and missing pieces
Every prompt in your program is written by a helper built on years of prompt-engineering work. If no building block does what you need, another helper writes one.
Tests every piece
Before it hands you the program, every piece has already run, on made-up values or on a real input you gave it, and anything that came out wrong has been fixed and run again.
Fixes a case and keeps it fixed
Hand it a case that has to work, like one that failed in production. Tangle works on the program until that case comes out right, then freezes that run, so any later run of the case shows exactly what changed.
Builds the frontend
Ask for a site or an app, and it builds one that talks to your program.
Deploys it
It puts the program on your own cloud, so it keeps running when your laptop is closed.
Works with
▶ Try it
Install Weft to click around in yours.
▶ Scoped runs
Feed it made-up values, a real input you saved, or the real services you connected. The rest of the program comes from the last run instead of running again.
Say a real case fails in production. Save it, work on the program until it comes out right, then freeze that run as the right answer for the case. After any later change, run it again and see exactly what moved on the wires.
This is why Tangle can test alone: it runs a piece, reads the result, fixes the step, and runs it again. You come back to a program that has already been run on real input.
▶ Why orchestration
Reliable
An agent has to hold the whole job together by itself. Here the program holds it, so a long job no longer depends on one model keeping track of everything.
Smarter
Scoped to its job, the model isn’t distracted by everything else the task touched, so it does it better.
Faster
An agent is one worker going step by step. 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 step here pays once.
Who decides what happens
01 / 04
01 · Who decides what happens
Reliable
An agent has to hold the whole job together by itself. Here the program holds it, so a long job no longer depends on one model keeping track of everything.
02 · How good the work is
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 step handed just its part
03 · How long it takes
Faster
An agent is one worker going step by step. A graph runs the pieces side by side, with no single bottleneck.
04 · What it costs
Cheaper
An agent re-reads the whole conversation every time it acts, and you pay for it each time. Each step here pays once.
each call re-reads the whole conversation
each step reads only its own input
▶ Flexibility
An orchestration can hold agents too: a step can be as open-ended as you want. The difference is that you decide the degree of freedom per step, like a contract. A bare agent is just the one extreme: a single step with the dial maxed and no rules.
Orchestration · the same run, freedom set per step
Locked
does one exact thing
Full agent
anything can happen
Scoped agent
free, but only these tools
Locked
does one exact thing
turn the dial from pure logic, up to a full agent, anywhere in between
An agent · one step, freedom maxed everywhere
full freedom is the only setting, and it covers everything at once
▶ Comparison
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 real edge was speed to start: nothing to set up, just prompt it. But Tangle builds so fast that building and running beats the agent doing it raw
build + run, end to end, beats the agent in most real cases
▶ Custom tools
To the llm, buy is one tool. You built what’s inside it: tiers, approvals and a secure payment, in minutes. And it’s a graph, so you watch every step run.
pick the next action to take
search the web for offers
ask the supplier a question
buy within the spending rules
route the order by its amount
under €100
buy now, capped €1k/hr
€100–1k
a teammate approves
over €1k
another team signs off
pay through the secure gateway
▶ Who it's for
Hobbyists & small businesses
Build the things that make your life easier
A phone line that books your clients, an agent that runs your store, a research bot that never sleeps. The kind of software that used to need a team of devs: describe it and ship it 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
▶ Humans
outreach · run
pauseddraft the email to this lead
approve or skip this lead
send the email once it's approved
Lead
Subject
Message
▶ Python vs Weft
import os, json, time, base64, threading, logging
from email.mime.text import MIMEText
from google.oauth2.credentials import Credentials
from google.auth.transport.requests import Request
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
import anthropic, psycopg2, psycopg2.extras
from flask import Flask, request, render_template_string, abort
SCOPES = ["https://www.googleapis.com/auth/gmail.readonly", "https://www.googleapis.com/auth/gmail.send"]
log = logging.getLogger("inbox-bot")
app = Flask(__name__)
def gmail_service():
creds = Credentials.from_authorized_user_file("token.json", SCOPES) if os.path.exists("token.json") else None
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token: creds.refresh(Request())
else: raise RuntimeError("run the oauth flow first") # TODO: who does this on the server?
open("token.json", "w").write(creds.to_json())
return build("gmail", "v1", credentials=creds, cache_discovery=False)
gmail, llm = gmail_service(), anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
db = psycopg2.connect(os.environ["DATABASE_URL"], cursor_factory=psycopg2.extras.RealDictCursor)
def decode_body(payload):
if payload.get("body", {}).get("data"): return base64.urlsafe_b64decode(payload["body"]["data"]).decode("utf-8", "replace")
for part in payload.get("parts", []) or []:
if part.get("mimeType") == "text/plain" and part["body"].get("data"): return decode_body(part)
for part in payload.get("parts", []) or []:
found = decode_body(part)
if found: return found # html only? strip tags? attachments?
return ""
def draft_reply(text, attempt=0):
try:
r = llm.messages.create(model="claude-sonnet-5-5", max_tokens=1024, messages=[{"role": "user", "content": text}])
return "".join(b.text for b in r.content if b.type == "text")
except (anthropic.RateLimitError, anthropic.APIConnectionError) as e:
if attempt >= 5: raise
time.sleep(2 ** attempt); return draft_reply(text, attempt + 1)
def poll_forever():
seen = {r["msg_id"] for r in query("SELECT msg_id FROM reviews")}
while True:
try:
res = gmail.users().messages().list(userId="me", q="label:inbox -from:me", maxResults=50).execute()
except HttpError as e:
log.warning("gmail list failed: %s", e); time.sleep(30); continue
for m in res.get("messages", []):
if m["id"] in seen: continue
msg = gmail.users().messages().get(userId="me", id=m["id"], format="full").execute()
headers = {h["name"].lower(): h["value"] for h in msg["payload"]["headers"]}
draft = draft_reply(decode_body(msg["payload"]))
execute("INSERT INTO reviews (msg_id, thread_id, sender, message_id, draft, status) VALUES (%s,%s,%s,%s,%s,'pending')",
(m["id"], msg["threadId"], headers.get("from"), headers.get("message-id"), draft))
seen.add(m["id"]); notify_reviewer(m["id"]) # slack? email? sms?
time.sleep(60)
@app.route("/review/<msg_id>", methods=["GET", "POST"])
def review(msg_id):
row = one("SELECT * FROM reviews WHERE msg_id = %s", (msg_id,)) or abort(404)
if request.method == "GET": return render_template_string(REVIEW_PAGE, row=row) # auth? csrf?
if request.form.get("decision") != "send": return mark(msg_id, "rejected")
reply = MIMEText(request.form["reply"])
reply["To"], reply["In-Reply-To"], reply["References"] = row["sender"], row["message_id"], row["message_id"]
raw = base64.urlsafe_b64encode(reply.as_bytes()).decode()
gmail.users().messages().send(userId="me", body={"raw": raw, "threadId": row["thread_id"]}).execute()
...
# query, execute, one, mark, notify_reviewer, REVIEW_PAGE, the
# schema, the deploy, restarts mid-review, a second worker, ...
...google = GoogleAccess email = GmailNewEmail { account: google.access query: "label:inbox -from:me"} draft = LlmInference -> (response: String) { prompt: email.body provider: OpenRouterProvider { model: "anthropic/claude-sonnet-5.5" }.provider params: LlmParams { systemPrompt: "Draft a short, friendly reply to this email." }.params} review = HumanQuery { fields: [ { "kind": "editable_textarea", "key": "reply" }, { "kind": "approve_reject", "key": "send" } ] reply: draft.response} send = GmailSend { _should_flow: review.send_approved account: google.access to: email.from replyTo: email.id text: review.reply}The same system, in a fraction of the code, and the AI writes it in a fraction of the tokens. So it builds faster and gets more right
And the compiler reasons about the orchestration, so it catches a broken system before it runs
▶ Dynamic vocabulary
A node can render scenes in Blender on a GPU, keep a browser open for other people to join, or call your own API or your own model. Whatever code can do, a node can wrap.
A node is a folder with two files: what it takes and gives back, and the Rust that does the work. Weft hands it credentials, storage and the record of every run, so the code only does the node’s own job. Write it yourself, or let Tangle write it.
A new node connects to any node whose types fit, the moment it exists. It can also list rules for how it must be wired, and the compiler flags any graph that breaks them.
Each node carries its own tests, run on your machine against fakes or live against the real service.
Nodes somebody built for their own job
render the scene on a GPU
keep a browser open to share
price the order with our rules
score the order with our model
▶ Folding
check for new leads every morning
look up the lead's company
decide whether the lead fits
draft the email to this lead
approve or edit the draft
send the email once it's approved
log the result in the CRM
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
Use the arrows on a group’s header to fold it or open it.
▶ And more
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
store the program's data in Postgres
started for you
Write pg = PostgresDatabase and the program gets a Postgres of its own. Drop in the WhatsApp bridge and it runs its own WhatsApp session, paired to your phone with a QR code. Neither one asks you for a line of YAML. Whoever writes a node like this deals with the hard part once, and after that anyone can drop it in. On your machine, all of it runs in Docker.
your machine
Docker
your cloud
Serverless
On your cloud, the program runs serverless: its workers cost nothing while they sit idle and scale up on their own when work arrives. Tangle runs the rest for you. Your part is logging in to Google Cloud and GitHub the first time (with a card on Google Cloud if you are new there), then running weft login prod yourself and pasting in your key.
carry the caller's audio both ways
turn speech into text live
decide what to say back
read the answer aloud to the caller
Build a phone-call agent where speech-to-text, the model, text-to-speech and the call stream all coordinate over one shared bus, in real time. You see every message they pass each other as it flows, and it’s all logged and replayable, so nothing is a black box
▶ Pricing
Price
$0
No plans, no seats, no usage meter
Self-hosted Weft stays free.
Fund development
If Weft is running your automations in production, put something back: one-time tips and monthly support both go straight into the build.
Fund on Ko-fi▶ Founder
I'm a software and ML engineer by training. The day ChatGPT came out I went full time on prompting and doing research on llm behavior. I spent the last three years breaking AI for a living: for Anthropic, OpenAI, METR, etc. The more I learned about how these models behave, the more I wanted to work on the system around them instead of the model itself.
Everyone is racing to get AI to actually do things now: act, call tools, run real processes. And we hand all of that to one agent and hope it carries the whole job from start to finish. Models are not there yet, and I don't want to wait years for them to catch up before AI can take on long, real jobs reliably.
Having built software for years, the answer is obvious to me: we need something shaped like a program, but with the same magic as an agent. A company already works this way: it chases one goal for years, even though each person only handles their own part and people come and go. Weft does the same in code. No model has to carry the whole job, because the program does, and it keeps going for days if it has to. Each agent or model call only gets a short job, the kind today's models already do well, so this works now instead of in a few years. And it's cheaper and faster than handing everything to one agent.
I believe this is the shape we'll all be building in a year, and no one else is looking here yet as a language design problem. Programming languages have always been the foundation on which the evolution of software has been built, and I believe right now is the time to build the one that will support this next generation of software.
