Any agent Claude · Codex · Cursor
Point Claude Code, Codex, or Cursor at Grid and describe the outcome — it builds tables, adds columns, and runs them through the MCP server while you watch.
v1.7.0 · macOSSource-available. Self-host free. Bring your own keys.
The headless GTM engine.
Grid is the headless GTM engine that runs your go-to-market programmatically. Enrich, score, route, and sync every record from Claude Code, MCP, the CLI, or a REST call — with a live grid so you always see what’s running.
Headless: MCP · CLI · REST Driven by Claude Code or Codex A live grid to watch it run
Name | Company | Titleenrich | Emailfind | Fitgenerate | |
|---|---|---|---|---|---|
| 1 | Alex Rivera | Linear | — | — | — |
| 2 | Maya Chen | Ramp | — | — | — |
| 3 | Jordan Okafor | Vercel | — | — | — |
| 4 | Priya Nair | Retool | — | — | — |
| 5 | Sam Delgado | Clay | — | — | — |
| 6 | Noa Friedman | Cursor | — | — | — |
| 7 | Liam Walsh | Browserbase | — | — | — |
One declarative manifest each. Works with the tools you already pay for.
Headless by design
One engine. Every surface.
Grid is a headless engine — your data, function columns, and connectors live in one place and run the same way no matter how you reach them. Drive it from the surface that fits the job, or all of them at once.
Pre-mapped, or anything 20+ connectors
Use the tools we’ve already mapped, or connect anything with one JSON manifest — it becomes an SDK call, an MCP tool, and a UI form.
NameTitleFit
Alex RiveraHead of Growth200
Maya ChenVP Sales200
Sam Delgadorunning—
A live grid
Watch every row move pending → running → done, with JSON collapsing into a clickable 200 pill.
$ grid run Founders --col Fit✓ 7/7 done · wrote to FoundersPOST /v1/columns/Fit/runmcp ▸ run_column "Fit"webhook ▸ row.created → enrich
CLI · MCP · REST · Webhooks
Call the same engine from a terminal, an MCP client, a REST endpoint, or an inbound webhook — no UI required.
The engine
Cells carry a status, not just a value.
Every column is a function — ai.generate, an enrichment connector, anything. Grid resolves {{Column Name}} templates per row and runs them with bounded concurrency — whether you hit Run, call the API, or let an agent drive.
1
Add a column
Manual text, number, boolean, date, or JSON — or make it a function column.
2
Pick a function
ai.generate, github.getUser, or any connector method like trigify.enrich.
3
Run
Every row resolves in parallel: pending → running → done. JSON results collapse into a clickable 200 pill.
// resolves per row, bounded concurrency
fn Title = trigify.enrich({
profile: {{LinkedIn URL}},
fields: ["title", "seniority"]
})
// row 1 → "Head of Growth"
// row 2 → "VP Sales"
// row 3 → Status Code: 200
Extensions
20+ connectors. Zero glue code.
Every connector is one JSON manifest — a baseUrl, auth, and methods. That single file becomes an sdk call, an MCP tool, and a UI form. Bring your own keys; credentials are encrypted and scoped.
Sm
Av
Headless control
Drive it from your agent.
Your agents can build anything you want. Point Claude Code, Codex, or Cursor at Grid, describe the outcome, and they use your pre-mapped connectors — or connect anything new — to build tables, add columns, and fill rows while you watch. It all runs on the subscription you already pay for — no API keys, no per-token bill.
You type
Using grid, create a table of these 10 founders and enrich each with their GitHub bio and company headcount.
Build anything you want. Your agent uses Grid’s pre-mapped connectors — or connects anything new — to build tables, add columns, and enrich rows.
Real-time. Rows fill in the grid as the agent calls tools — you see every status flip.
Three agents, one surface. Claude Code, Codex, and Cursor — on the subscription you already pay for, no API keys.
Claude CodeCodex
Cursor
You
Add a column that scores GTM fit 0–100 and run it.
create_column name="Fit" fn="ai.generate"
run_column "Fit" · 7 rows
✓ 7/7 done · 1 credit/row · wrote to Founders
Done. "Fit" is live on all 7 rows — top match is Sam Delgado at Clay (96). Want me to sort descending?
›Quick start
# Clone and run from source. Needs Node 20+ and pnpm.
$
git clone https://github.com/badapplesdotdev/gtm-grid.git && cd gtm-grid && pnpm install && pnpm tauri:devSigned desktop builds for macOS, Windows, and Linux — or run it from source. The CLI and MCP server run anywhere Node does. All platforms & versions →
Source-available
Free to self-host. Cloud when you need it.
Grid is source-available and free to self-host — point it at your own Postgres, ship your own connectors, send the good ones back as a PR. Cloud is where it gets serious: managed Postgres, your whole team on the data, and every grid running while you’re away.
Self-host · FSL-1.1-MIT
Self-host on your own Postgres
Run the backend against a Postgres you control — a local Docker image or your own server. Your keys and execution stay on your machine, and the full source is yours to read, fork, and extend.
- Unlimited rows, tables & function columns
- Every connector — bring your own keys
- Fork it, build connectors, open a PR — features ship from the community
- Powered by your own Claude Code or Codex — AI columns run on the subscription you already pay for
Hosted · from $20
Cloud, for when you step away
The same grid, hosted — so it keeps running with your laptop closed, fires on incoming events, and opens up to your whole team.
- Runs when your computer’s asleep — scheduled refreshes keep firing
- Webhooks — new rows enrich themselves on inbound events
- Team access — shared workspaces & credentials
- Realtime multiplayer on shared grids
Under the hood — how it works
Postgres source of truth
Tables, columns, and cell history live in Postgres — your own self-hosted instance, or our managed cloud.
Keys stay on your machine
Your connector & AI keys live in a local vault, AES-256-GCM encrypted on disk. Execution runs locally — keys never leave your machine.
Sandboxed logic
Column functions run in a QuickJS sandbox with a declarative HTTP layer. Predictable, bounded, no surprises.
Cloud pricing
Self-host free. Cloud is metered.
Self-host on your own Postgres for free. Cloud plans are billed per seat and metered by cloud actions — runs that happen on our infrastructure instead of your machine. No row, table, or connector caps, ever.
Self-host — $0, source-available, unlimited. Cloud only covers runs on our infrastructure.Download free
Free
Local & solo, forever.
$0/ forever
No account, no card
Runs 100% on your machine
Cloud actions — paid plans only
- The full source-available desktop app
- Unlimited rows, tables & functions
- Every connector — bring your own keys
- Local-only — cloud needs a paid plan
Team
Shared cloud grids for small teams.
$20/ seat / mo
Billed monthly
50,000 cloud actions / mo
Overage — then $0.50 / 1,000
- Everything in Free, in the cloud
- Cloud sync & realtime multiplayer
- Shared workspace credentials
- Webhooks & scheduled runs
RecommendedStart 7-day trial
Business
5× the headroom, lower overage.
$40/ seat / mo
Billed monthly
250,000 cloud actions / mo
Overage — then $0.40 / 1,000
- Everything in Team
- 5× the included cloud actions
- Lower overage — $0.40 / 1k vs $0.50
- Shared workspace credentials
Unlimited
No metering. No overage. Ever.
$99/ seat / mo
Billed monthly
Unlimited cloud actions
Overage — no overage, no caps
- Everything in Business
- Unlimited cloud actions — no metering
- No overage charges, ever
- Realtime multiplayer + shared credentials
What counts as a cloud action?
Any run executed on our cloud instead of your machine — a function-column cell, a webhook fire, or a scheduled refresh. Runs on the desktop app are always free.
Metered by actions, not rows
Each member is one seat. Allowances are per seat and pool across the workspace. Rows, tables, and connectors are never capped — only cloud actions are.
Self-hosting is always free
Source-available under FSL-1.1-MIT, unlimited on your own Postgres. Cloud is purely additive — for when grids need to run without you.
FAQ
The honest answers.
The engine isn't tied to a dashboard. The same tables, function columns, and connectors are driven from Claude Code, an MCP client, the CLI, a REST call, or a webhook — and the desktop grid is just one head on top, so you can watch every row fill as it runs.
In Postgres — your own self-hosted instance (a local Docker image or your own server) for free, or our managed cloud. Either way your connector and AI keys stay in a local encrypted vault, column logic runs in a local QuickJS sandbox, and the only outbound traffic is the connector and AI calls you trigger, sent directly to those providers.
No. Grid is source-available (FSL-1.1-MIT) and free to self-host — point it at your own Postgres and you're unlimited, local and solo. Cloud is an optional layer you turn on only when a grid needs to run without you: scheduled refreshes while your laptop's closed, webhook triggers, team workspaces, and shared credentials. If you never need those, you never pay.
You add your own Anthropic / OpenAI key and your existing connector keys. Grid adds no markup — you pay providers their list price, and the app itself is free. AI columns can also run on your own Claude Code or Codex subscription.
Drop a JSON manifest into
extensions/ with a baseUrl, an auth block, and your methods. It immediately becomes an sdk.<id>.<method>() call, an MCP tool the agent can use, and a connection form in the UI.No. The grid works fully on its own — add columns, pick functions, hit Run. The Claude Code / Codex panel is there when you'd rather describe what you want than click through it.
It's a Tauri v2 desktop app. Signed builds ship for macOS, Windows, and Linux; the CLI and MCP server run anywhere Node does.
Run your go-to-market
headless.
Install Grid, point it at your keys, and drive your first grid from Claude Code, the CLI, or an API call in minutes.
$git clone https://github.com/badapplesdotdev/gtm-grid.git