Swirl Background - Animated Topographic Lines
Early Access Now Open

THE SWISS ARMY KNIFE
FOR BUILDING AI WORKFLOWS

Visual graph builder for HTTP calls, LLM reasoning, and data transforms. Deploy instantly. When you need to integrate into your app, we generate a type-safe SDK—no API wrestling, full IntelliSense, compile-time safety.

Start with templates or build from scratch. Add code only when you need it.

START BUILDING FREESEE THE CODEGEN DEMO
No infrastructureType-safe integration1,000 free executions/month
What can you build?

PIPELINES FOR EVERY USE CASE

Connect any data source to any destination. Swirls orchestrates your entire GTM stack with AI-powered transformations at every step.

LEAD ENRICHMENTLIVE

Automatically enrich incoming leads with firmographic data, score them against your ICP, and route qualified leads to your CRM.

Type-Safe SDK

TYPE-SAFE END TO END

Generate TypeScript types from your workflows with a single command. Embed forms, execute pipelines, and build integrations with full autocomplete—no manual type definitions required.

01
One command codegenswirls dev gen outputs Zod schemas
02
Strongly-typed formsFull IntelliSense and validation
03
Any form libraryWorks with React Hook Form, TanStack, or plain React
04
Workflow executionSubmit triggers your graph automatically
terminal
$ swirls dev init

? Enter your project ID: a1b2c3d4-e5f6-7890-abcd-ef1234567890
✓ Created swirls.config.ts

$ swirls dev gen

✓ Fetching project schemas...
✓ Converting JSON schemas to Zod...
✓ Generating form registry...
✓ Writing to src/swirls.gen.ts

Generated:
  → 3 form schemas
  → Type-safe registry
  → Module augmentation

Types are ready! Import from '@/swirls.gen'
The Context Problem

TOKEN ECONOMICS ARE BROKEN

Right now, agentic workflows are hemorrhaging tokens. Every MCP tool call dumps the entire API response into your LLM context. The agent reads 12,500 tokens to extract 3 tokens of value.

LLM reading entire API responses to find one field
Repeated context about what tools do
Back-and-forth debugging when tools fail
Re-fetching data that was already fetched
Traditional MCP
Agent → "fetch company data" tool
  ↳ MCP tool executes fetch('https://clearbit.com/...')
  ↳ Returns 50KB JSON response
  ↳ Agent receives entire response IN CONTEXT
  ↳ 12,500 tokens consumed
  ↳ Agent extracts employee count: "450"
  ↳ Useful data: 3 tokens
  ↳ Wasted: 12,497 tokens (99.9%)

Agent → "fetch tech stack" tool
  ↳ Another 10,000 tokens in context
  ↳ Agent orchestrates in LLM
  ↳ Non-deterministic output
Total tokens22,500+
Swirls Graph
Agent → "enrich_lead" graph (single call)

Graph executes deterministically:
  ↳ HTTP node: fetch Clearbit    (0 context tokens)
  ↳ HTTP node: fetch BuiltWith   (0 context tokens)
  ↳ Code node: extract fields    (0 context tokens)
  ↳ LLM node: score lead         (500 tokens)
  ↳ Code node: format output     (0 context tokens)

Returns: { company: "Acme", employees: 450, score: 85 }
Total: ~700 tokens (97% reduction)
Total tokens~700
97%
Token reduction
100%
Deterministic
Faster
No LLM orchestration

The insight: Swirls graphs move orchestration logic OUT of the LLM context and INTO deterministic execution. The agent gets exactly the data it needs, in exactly the format it needs, every single time.

The Differentiator

TYPE-SAFE INTEGRATION CHANGES EVERYTHING

Other visual builders force you to call their API with stringly-typed payloads. Typos become runtime errors. Schema changes break production silently. Swirls generates a type-safe SDK that catches errors at compile time.

Other Visual Builders
api-call.ts
const response = await fetch(
  'https://example.com/api/hooks/abc123',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      emial: formData.email,  // typo - fails at runtime
      comapny: formData.company  // typo - fails at runtime
    })
  }
);

const data = await response.json();
console.log(data.scroe);  // typo - fails at runtime
console.log(data.emplyees);  // typo - fails at runtime
No IntelliSense
Typos found at runtime
Schema changes break silently
Manual type definitions
Swirls SDK
lead-form.tsx
import { useSwirlsFormAdapter } from '@swirls/sdk/form'

const adapter = useSwirlsFormAdapter('enrichLead', {
  email: '',
  company: '',
})

const result = await adapter.submit({
  emial: formData.email,
  // ^ TypeScript Error: Property 'emial' does not exist.
  //   Did you mean 'email'?
})

console.log(result.scroe)
//          ^ TypeScript Error: Property 'scroe' does not exist.
//            Did you mean 'score'?
Full IntelliSense
Errors caught at compile time
Schema changes show as TypeScript errors
Types generated automatically

IntelliSense Everywhere

Your editor shows required fields, optional fields, and output types as you type.

Compile-Time Safety

TypeScript catches typos and missing fields before your code ever runs.

Easy Updates

Changed your graph? Run swirls dev gen and fix TypeScript errors.

The Problem

AUDITABILITY IS UNDERRATED

When agents build tools in traditional systems, you're flying blind. The orchestration happens inside the LLM—non-deterministic, impossible to test, and a nightmare to debug. Every execution is a black box.

Opaque execution

When an agent builds a tool in traditional systems, it's opaque. What did it do? Why did it fail?

Non-deterministic

Will the agent orchestrate the same way twice? Probably not. Same inputs, different outputs.

Hard to debug

Something broke? Good luck figuring out which step failed and why. It's buried in LLM reasoning.

This is where Swirls changes the game. When an agent builds a Swirls graph, you can see every step. You can test it, version it, share it. The tools ARE the documentation.

The Solution

LITERATE AGENTIC PROGRAMMING

When an agent builds a Swirls graph, everything changes. The graph is the documentation. The execution is deterministic. The debugging is trivial.

See the graph

Visual representation: HTTP → LLM → Decision → Output. Every step is visible.

Test the graph

Run it with sample inputs. Debug step-by-step. Know exactly what happened.

Version the graph

Git commit it. Track changes over time. Roll back when needed.

Share the graph

Other agents can use it. Your team can use it. Reusable, composable primitives.

The Meta-Move

Agents Building Their Own Tools

This is where it gets wild. Instead of calling 5 different MCP tools every time, an agent can build a Swirls graph that encapsulates the pattern. From then on, it's a single call—deterministic, token-efficient, and perfectly reproducible.

1
Agent realizes "I'm doing this pattern a lot"
2
Uses Swirls to build a graph: account_research_tool
3
Graph encapsulates: fetch → enrich → analyze → format
4
Every subsequent time: zero token waste, perfect reproducibility

This is agentic workflow compilation. Repeated patterns become optimized, reusable primitives.

Graph outputs persist to encrypted streams and can feed into other workflows—enrichment pipelines, progressive data models, feedback loops that get smarter over time. That's why we called it Swirls.

For everyone on the team

NOT A BUILDER? NO PROBLEM.

Any member of your team can join your organization and consume the automation you've built, by submitting forms and tracking status and submissions through an extremely intuitive UI. They never have to build anything. Just use what you ship.

Submit forms

Fill out and submit forms your team has built. No config, no code. Just the fields you need.

Track status & submissions

See your submissions and their status in one place. Know when something’s done or needs attention.

Intuitive UI

Designed for people who run on automation, not people who build it. No learning curve.

Invite teammates to your org. They get a simple, focused experience: forms to submit, a clear view of their submissions and status. Builders own the graphs and triggers; everyone else just benefits.

READY TO BUILD?

Start automating your GTM motion with workflows that don't break.

START BUILDING FOR FREEREAD THE DOCS