Early Beta

Ship AI systems
20× faster than Claude Code

Describe what you want, the AI builds it,
you guide it with your expertise
An autonomous builder powered by a language
designed for AI systems

Start Building Star on GitHub Join Discord

Not ready to sign up? Follow the build

No spam. Occasional updates on what I ship and what is coming.

Our founder stress-tested AI for

OpenAI

Anthropic

METR

Amazon AGI

Proof

Your team ships in minutes, not hours

Same AI model builds the same system. WeaveMind finishes in 4 minutes, Claude Code takes 1h 30

Both videos play in sync on a shared timeline

0:00 1:30:00

WeaveMind

4 min

Time

600

Lines of code

Errors

Claude Code

1h 30

Time

2.2k

Lines

Errors

Watch full recording

Built for

Teams that ship AI

Whether you're delivering AI to enterprise clients or shipping it inside your own company

AI Consultancies & Agencies

Your solutions engineers customize per client in hours, not weeks

Describe your client's workflow, the AI builder assembles it. Your solutions engineers customize and iterate. White-label it under your brand

Internal AI Teams

Your CEO wants AI. Your team of 5 needs to actually deliver it

You don't need AI engineers. Describe what you need, use your domain knowledge to guide the builder. It handles the architecture, you handle the expertise

Or you could

Use n8n

AI builder breaks past 3 nodes. Your team ends up building around it anyway

Build from scratch

3 weeks to build each system, then maintain every single one of them forever

Hire 5 more engineers

$800k/year and they'll still spend half their time on integration code

Why a new language

AI systems need a language designed for them

LLM calls, databases, APIs, human decisions, browser agents. In Python, each one is a library, a config file, and fifty lines of glue. In Weft, each one is a base ingredient, the way int and for are base ingredients in C. That's why the AI builder is so fast: it's assembling ingredients instead of generating boilerplate

Compact, uniform, type-safe. The AI writes it correctly because the compiler rejects bad architecture. You review it visually because Weft compiles to a graph you can actually read

Python app.py

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)

Weft app.wft

db       = PostgresDatabase
qualify  = LlmInference { parseJson: true }
review   = HumanQuery "Review Email"
send     = EmailSend

qualify.prompt = db.rows
review.body   = qualify.draft
send.body     = review.body

database + LLM + human review + email, 7 lines

Outreach review Approve or skip this lead

1 / 3

Lead

Sarah Chen · VP of Engineering Acme Robotics

Subject

Message

Human-in-the-Loop

When the AI needs a human, it asks

The future isn't about removing humans from the loop. It's about putting them where they matter: taste, field experience, judgment calls. The AI handles the engineering, the plumbing, the testing. Humans stay in for the decisions that need them

One node in the graph, no engineering required. The system pauses, sends a form to the right person, waits hours or days, then resumes exactly where it left off. A browser extension delivers the task inline, or share a link and anyone can review without touching the project.

Start building

Same program, two views

Read it as code. Review it as a graph.

Weft code compiles to a visual graph automatically. Same program, two representations.
The AI writes the code, you navigate the graph.

Loading playground...

this was built in one prompt, in under a minute

Esc

Suggested

LLM AI

Code Utility

Human Flow

WhatsApp Bridge Infrastructure

Postgres Database Infrastructure

First-Class Primitives

The vocabulary of 2026

LLM call, database, browser agent, cron job, human approval, API endpoint, all primitives. You don't import them, you don't configure them, they exist in the language the way int exists in C

Every primitive typed and validated at compile time. Need one that doesn't exist yet? Build your own by customizing what the language already gives you, the AI picks it up immediately because the structure is uniform

Cron

trigger

outreach pipeline

API

enrich

LLM

qualify

outreach actions

LLM

draft

Human

review

send

API

log result

Recursively Foldable

A hundred nodes still look like five

Any group of nodes collapses into a single node with a description, typed inputs, and typed outputs. Groups nest within groups. Five boxes at the top level, zoom into the one that matters, everything else stays folded.

n8n, Make, LangGraph all turn into spaghetti past 20 nodes. They have no recursive scoping. Weft does. And because the AI writes the code, you skip the tedium of clicking nodes around a canvas.

Coming Soon

The language is growing

This is version 0.1. Every feature below makes the AI more capable, because the language and the AI co-evolve

Agents as Primitives

Long-lived agents in the graph

An agent is a node that persists, manages its own state, and acts through explicit edges. Every tool call visible in the graph, every decision traceable

LLM flexibility with graph-level observability. No black-box agents. Every tool call, every decision, visible in the graph as it happens

Agent

iter: 3

research_agent

state: researching · 3 sources found

Web

LLM

extract

Memory

store

Verified Blocks

Pre-approved building blocks you customize

A RAG pipeline, a moderation layer, an agent with hallucination watchers. Drop a verified block into your program, customize it, and your system inherits its guarantees

Because Weft programs have structure, the compiler can do architectural analysis: automatically flag when user input flows into an AI without a filter, or when multiple AI calls are chained without a hallucination check.

safe_outreach verified

Guard rate_limit

Guard dedup_check

Human approval

Compilation

Weft compiles to a binary

Weft compiles to native Rust. Same performance as hand-written code, zero overhead. The binary provisions its own infrastructure, starts triggers, and runs as a service. One artifact, deploy anywhere.

AI writes a high-level graph. The compiler turns it into systems-level code. Compile once, then run it, serve it as a long-lived process, or manage its infrastructure independently.

terminal

$ weft compile outreach.wft

✓ Parsed 12 nodes, 14 edges

✓ Type-checked all connections

✓ Compiled to native binary

→ ./outreach (4.2 MB, linux/amd64)

$ ./outreach serve

✓ Infrastructure provisioned

✓ Triggers listening

Serving · waiting for events

Built in Rust

Compiler, runtime, type system, AI builder. All Rust

Compiled

Not interpreted

Type-safe

Compile-time validation

Parallel

Native concurrency

Pricing

We pass down our volume discounts on LLMs and every other service we use.
Our AI builder is efficient enough that even with the margin, you pay less than doing it yourself

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

Quentin Feuillade--Montixi

Founder & CEO

I spent three years breaking AI systems. Red teaming for OpenAI and Anthropic, capability evaluations at METR, building an AI evaluation startup. I presented an autonomous jailbreaking system at the Paris AI Summit.

The fixes are almost always simple: add a check, add a filter, improve the prompt, put a human in the loop. Stack enough layers and the holes stop lining up. But each layer is more plumbing, and I've watched small teams burn hundreds of thousands of dollars just keeping that plumbing alive.

I started by building an AI coding agent for these systems. The models kept falling into the same bad patterns, and no prompt was strong enough to pull them out. So I stopped trying to steer the model and built the first language designed to be written by AI. Every other language was designed for humans, then handed to models as an afterthought. Weft is the inverse: the compiler catches what's broken, good patterns are enforced by the language itself, and you get a visual graph of your system for free. Humans stay in the loop where they belong: taste, domain expertise, judgment.