Turn the World into a function
Schema is building an API for the World: every website, callable by agents, fast and accurate. Use it on your Mac, build on it with the API, or put your own site on it.
The web has one interface, and it was built for people. We’re building the second one.
Read the visionOne vision. Three ways in.
Everything we build serves one idea: an API for the World. Every website, callable by agents — fast and accurate. Use it yourself, build on it, or put your own site on it.
Schema for Mac
Ask for anything. Schema calls the web and hands back the answer.
A command bar for your Mac. Say what you need in plain English; Schema turns it into function calls, runs them, and returns the result as clean Markdown. Passwords and 2FA codes stay in an on-device Vault the model never sees.
Schema API
Call any website like an API.
Every site gets a machine interface: what it does, how to use it, and the functions you can call, with their types. Hook it into the agents you already run and they get typed responses instead of scraped pages.
Schema for Sites
Zero-config. Your site, as an API for every agent.
Like Cloudflare, for the world of agents. Schema sits in front of your existing site and turns it into an API every agent can call — more traffic, more conversions, more reach, with no rebuild.
Schema for Mac
Ask for anything. Schema calls the web and hands back the answer.
If you can ask for it, Schema can go get it
Flights, carts, reservations, bills, fine print. You describe the outcome, Schema turns it into function calls, and the typed results come back as clean Markdown: tables, checklists, quotes, whatever fits.
“Find a nonstop to Lisbon under $700 the second week of May”
- →flights.search(to: "LIS", max_price: 700, nonstop: true)
- →flights.hold(id: "TP202", seat: "23A")
3 nonstops under $700
| Flight | Route | Departs | Price |
|---|---|---|---|
| TAP 202 | EWR → LIS | Sun, May 11 · 7:50p | $642 |
| United 64 | EWR → LIS | Mon, May 12 · 5:35p | $671 |
| TAP 204 | JFK → LIS | Tue, May 13 · 9:10p | $688 |
Seat 23A held on TAP 202. Press ⌘↵ to book it.
“Get me the earliest DMV slot for a license renewal”
- →dmv.appointments(type: "renewal", sort: "earliest")
- →dmv.hold(slot: "2026-10-06T09:20")
Tue, Oct 6 at 9:20am · Fell St
- Appointment held
- Confirmation
DMV-7Q2K - Bring your current license
- $38 renewal fee
“What’s the return window on this jacket, and is shipping free?”
- →store.policy(topic: "returns")
30 days
Returns ship free, with one catch:
“Items must be unworn with original tags attached.”
“Compare what the filters cost for these three air purifiers”
- →products.compare(ids: [3], fields: ["price", "filter_cost"])
The cheapest to buy isn’t the cheapest to own
| Purifier | Price | Filters / yr | 3-yr total |
|---|---|---|---|
| Coway 200M | $34 | $251 | |
| Levoit 400S | $219 | $58 | $393 |
| Blueair 211i | $319 | $71 | $532 |
“Book a table for four somewhere quiet near Union Square at 7:30”
- →reservations.search(near: "Union Square", party: 4, at: "19:30")
- →reservations.book(venue: "Cotogna", slot: "19:30")
Booked · Cotogna
- 1Checked 6 spots within a 10-min walk
- 2Ruled out 4 with “loud” in reviews
- 3Reserved 7:30pm, party of 4
Confirmation OT-55190
“Log into PG&E and pay this month’s bill”
- →pge.sign_in(credentials: vault("PG&E"))
- →pge.pay(amount: 112.40, from: "checking")
$112.40
Paid from checking ••4417
- Due Oct 14, paid Sep 23
- Receipt sent to your inbox
“Check our registrar for any domains expiring this quarter”
- →registrar.domains(expiring_before: "2026-12-31")
2 of 8 expire before Dec 31
schema.dev· Nov 14 · auto-renew offgetschema.co· Dec 2 · auto-renew off
The other 6 renew automatically.
Fast because there’s nothing to click
Schema doesn’t wait for pages to load or hunt for buttons. It calls functions, gets typed responses, and moves on.
Every site, as functions
Schema maps a website into callable functions with typed arguments. Search, filter, book, pay: each one is a call, not a sequence of clicks.
Calls, not clicks
No waiting for pages to render or buttons to appear. A call goes out, a typed response comes back, and Schema moves on.
Errors it can actually handle
A failed call returns a real error, not a frozen spinner. Schema fixes the arguments, tries again, and keeps going until the goal is met.
Speak it instead
Real-time macOS dictation is built into the bar. Say the task, get the answer.
Answers, not logs
Typed responses come back into the same bar as clean Markdown: the flight, the price, the confirmation.
Runs on your Mac
Schema is a standalone app, not a browser extension. Your Vault stays encrypted on your machine.
Four keystrokes between you and done
Schema lives one shortcut away. It’s built for the tiny errands you’d otherwise open six tabs for.
Summon it anywhere
The bar opens on top of whatever you’re doing. No tab to find, no app to switch to.
Type it or say it
Plain English works. So does talking — dictation is built in and transcribes as you speak.
Schema makes the calls
Your request becomes a handful of function calls. You watch them go by in the bar: no windows, no tabs, no cursor.
Confirm what matters
Anything that spends money or can’t be undone waits for your go-ahead. Everything else just happens.
Logs in for you. Never sees your password.
Connect passwords, 2FA codes, emails, usernames, or any other secret to your Vault. Schema can pass them into any call that needs them, but the model itself never gets to read them.
- Encrypted on your Mac
- Secrets are encrypted and stored on device, and only unlocked when a task needs one.
- Invisible to the model
- Schema asks for a secret by name. The Vault passes it straight into the function call, so the value never enters the model’s context.
- Fetched only on demand
- Nothing is loaded up front. A secret is retrieved at the moment the model calls for it, and not before.
- 2FA included
- Store one-time codes alongside passwords, so logins with two-factor don’t stall halfway through.
- PG&EPassword••••••••••••
- PG&E2FA code••• •••
- Work emailEmailk••••@schema.dev
- RegistrarUsernameschema-ops
- Frequent flyer #Secret••••••7731
vault("PG&E")••••••••••••Built to feel instant, not clever
Speed isn’t a setting Schema turns on. It’s the default, and everything else is the exception.
- 01
Maps before it acts
Schema turns a site into typed functions first, so it knows exactly what’s possible before it does anything. No fixed scripts to break when a site changes.
- 02
Calls the instant it’s sure
Routine calls go out immediately. There’s no waiting around for a slow model to confirm the obvious.
- 03
Thinks only when it has to
Real judgment calls — which fare, which result, which arguments — get the deeper reasoning they deserve, and nothing else does.
- 04
Keeps going until it’s done
A failed call comes back as a typed error. Schema adjusts and retries, and only stops once the goal is verifiably met.
Most agents spend their time clicking. Schema just calls.
Browser agents are slow because they act like people: wait for the page, look, click, repeat. Schema skips the performance. It calls functions directly and saves the deeper thinking for the few moments that need it.
Illustrative benchmark on a fixed Google Flights route. Your mileage will vary with the site.
- 4.8s
- Flight booked end-to-end on Google Flights
- 0
- Clicks, scrolls, or page loads
- ~90%
- Of calls made without a slow model in the loop
- 24/7
- Same speed, no warm-up, no rate-limit wall
Schema API
Call any website like an API.
Call any website like an API
Most of the web will never ship an API. The Schema API gives every site one anyway: a machine interface agents can read, call, and trust, with typed responses in place of scraped pages.
Search, compare, and track flights across airlines. Returns itineraries with prices, times, and fare rules.
Start with search_flights, then pass an itinerary id to get_fare_details or track_price.
search_flights({ from: "SFO", to: "JFK", depart: "2026-10-02", nonstop: true })[ { "id": "itn_7Kq2", "flight": "B6 916", "departs": "07:05", "arrives": "15:37", "stops": 0, "price": { "amount": 187, "currency": "USD" } }, { "id": "itn_9Rt4", "flight": "AS 1428", "departs": "09:40", "arrives": "18:15", "stops": 0, "price": { "amount": 204, "currency": "USD" } } ]
- 01
A spec for every site
Each website gets a machine interface: a description of what it does, how to use it, and every function you can call, with typed arguments and typed returns.
- 02
Hooks into your agents
Hand the functions to the agents you already run as tools. No per-site integration, no scrapers, no brittle selectors to maintain.
- 03
Fast and accurate
Calls go straight to the action and come back as validated, typed responses. When something fails, you get an error you can handle, not a frozen page.
- 04
The whole web, one API
Flights, stores, reservations, bills, forms. One integration gives your agent the entire web instead of the handful of sites that ship their own APIs.
Schema for Sites
Zero-config. Your site, as an API for every agent.
Turn your site into an API for every agent
Schema for Sites is the Cloudflare for the world of agents. Put it in front of your existing site and it becomes a fast, typed API that agents can call — you choose what’s exposed. Your customers get things done, agents get a reliable way in, and you get the business. A win for everybody.
search_flights({ from: "SFO", to: "JFK", date: "2026-10-02", nonstop: true })[ { "id": "AC916", "departs": "07:05", "arrives": "15:37", "price": { "amount": 187, "currency": "USD" }, "seats_left": 4 }, { "id": "AC1428", "departs": "09:40", "arrives": "18:15", "price": { "amount": 204, "currency": "USD" }, "seats_left": 11 } ]
More traffic
Agents are becoming how people shop, book, and search. Sites they can actually use are the ones they send people to.
Higher conversion
An agent that can call checkout finishes the purchase instead of stalling on a dropdown or a cookie banner.
Wider reach
Every assistant, model, and agent becomes a channel to your customers, through one integration instead of one per provider.
Zero config, no rebuild
Schema sits in front of your existing site like Cloudflare. Your backend and your pages for people stay exactly as they are.
An API for the World
Everything we build serves one idea. Machines shouldn’t have to pretend to be people: today’s agents look at pages designed for human eyes, find buttons sized for human fingers, and click them. Machines talking to machines should work fundamentally differently, so Schema is building the interface they deserve: every website, callable, fast and accurate.
Humans click. Machines call.
Humans read pages. Machines read types.
Humans wait for things to load. Machines get a response.
The end game: be the Cloudflare for the new world of agents — the layer every site sits behind, and every agent calls through.
- Now
Call any website
Schema for Mac and the Schema API turn today’s websites into functions that you and your agents can call, with typed answers instead of clicks.
- Next
Sites that speak machine natively
Schema for Sites: zero config, like Cloudflare. Any business puts Schema in front of its site and becomes a native API for every agent.
- Eventually
An API for the World
Every booking, purchase, form, and lookup on the internet is a fast, accurate function with a signature. The world, turned into an API.
Stop clicking. Start calling.
The waitlist is open for Schema for Mac and the Schema API. Join and we’ll email you as spots open up. Running a business? Schema for Sites is by conversation.
The first 1,000 on the waitlist get in mid-October, with everything free for a month.
Schema for Mac: Apple silicon · macOS 14 or later
- 1
Join the waitlist
Takes under a minute. The first 1,000 get a free month.
- 2
Get your invite
The first 1,000 are admitted in mid-October.
- 3
Sign in with the same email
Use the address you joined the waitlist with.