cohesivity
Run the curl →
// Agent-native backend infrastructure

One curl provisions your entire backend

Cohesivity is one HTTP API in front of 14 backend services — database, Redis, object & vector storage, hosting, Workers, realtime, auth, and AI proxies. No per-vendor signups. No keys to copy-paste. Built so AI coding agents stand up a full backend in a single call.

$ curl -s -X POST https://cohesivity.ai/api/genesis > .cohesivity
Run the curl → Read the docs →
14
Services
0
Vendor signups
1
Bearer token
72h
Ephemeral window
Used by builders shipping real product
Masters Union switched from Emergent 3 paying customers 14 services in 70 days 8,000+ line changelog 72-hour ephemeral tenants one curl to backend
// The friction

Standing up a backend is death by a thousand dashboards

Every new app means a dozen vendor signups, a dozen consoles, a dozen API keys copy-pasted into a dozen .env files, and a dozen billing accounts to reconcile. Worse — your AI agent can’t do any of it. It hits a browser auth wall and waits for you. We killed all of it.

01

No more per-vendor signups

One API, one auth. You don’t create a Cloudflare, Pinecone, Upstash, OpenAI, and Resend account. We did.

02

No more copy-pasted keys

Cohesivity injects every upstream credential server-side. Nothing to leak, rotate, or paste into the wrong repo.

03

No human in the loop

Genesis-to-edge is pure HTTP. Your agent provisions a full backend with zero console clicks while you sleep.

04

No context loss between sessions

An 8,000-line changelog means your agent reads the full company brain every session and never re-litigates a decision.

// How it works

Genesis. Provision. Query. Ship.

01

Genesis

One POST mints an ephemeral tenant and a manager token. No signup, no email, no console. The token lands in a .cohesivity file your agent reads.

curl -s -X POST https://cohesivity.ai/api/genesis > .cohesivity
02

Provision

Hit the resource endpoint with your manager token. A real per-tenant D1 database in the region you ask for. We inject the upstream keys server-side.

curl -s -X POST https://cohesivity.ai/api/resources/database \ -H "Authorization: Bearer coh_man_..." \ -H "Content-Type: application/json" \ -d '{"primary_region":"apac"}'
03

Query

Run SQL over HTTP through the edge with a session token. No driver, no connection pool, no string to leak. Just rows back.

curl -s -X POST https://cohesivity.ai/edge/database/query \ -H "Authorization: Bearer <session_token>" \ -d '{"sql":"SELECT * FROM users LIMIT 10"}'
04

Claim

Like what you built? Claim the tenant with Google before the 72-hour window closes. Free, Plus, or Pro — one subscription, one shared wallet.

# Open the claim URL, sign in with Google. # Your ephemeral tenant becomes permanent.
// The catalog

14 backend services. One bearer token.

Every box below is one API call away. No vendor signup. No key copy-paste. Cohesivity injects the credentials server-side — you just hit the endpoint.

DATA

database

Per-tenant D1 with raw SQL over HTTP. One curl writes rows.

Cloudflare D1
DATA

redis

A Redis namespace per tenant, REST-native. Cache without a connection string.

Upstash Redis REST
DATA

object-storage

R2-backed blobs with authenticated writes and deletes. No bucket policy archaeology.

Cloudflare R2
DATA

vector-database

Pinecone vectors with per-tenant namespace isolation. RAG without the Pinecone console.

Pinecone
EDGE

vercel-hosting

Ship tenant apps to Vercel straight from multipart file uploads.

Vercel
EDGE

cloudflare-workers

Deploy tenant Workers, cron included. Edge compute, zero dashboard.

Cloudflare Workers
COMMS

realtime

WebSocket channels, publish, history, and Durable Object room fanout.

Cloudflare RealtimeKit
COMMS

social-login

Google OAuth for tenant apps, a user list, and an auth-event table in D1.

Google
AI

openai-api

OpenAI Responses, embeddings, and gpt-image-2, gated by launch tier.

OpenAI
AI

deepgram-api

nova-3 STT, Aura-2 TTS, and Voice Agent on flux-general-en v2.

Deepgram
AI

exa-api

Exa search and research surface, tier-gated. Give your agent the live web.

Exa
COMMS

resend-api

Resend proxy for transactional email. Send without an SMTP saga.

Resend
EDGE

openweather-api

Current conditions plus a 5-day, 3-hour forecast proxy.

OpenWeather
EDGE

google-geocoding-api

Google Geocoding proxy for address-to-coordinate lookup.

Google
// THAT’S THE WHOLE BACKEND

Fourteen providers. One auth. Zero consoles.

Run the curl →
// The edge

OpenRouter for backends. Not another monolith.

Supabase and Firebase hand you one stack and call it a platform. We aggregate the real providers — Cloudflare, Pinecone, Upstash, OpenAI, Deepgram, Exa, Resend — behind one bearer token, and inject the keys server-side.

Supabase MCP still makes your agent open a browser and click. Emergent burns credits in debugging loops and makes you babysit a wallet. We built agent-native on day one: genesis-to-edge in HTTP, zero console clicks, and an 8,000-line changelog your agent reads every session so it never loses the plot.

CloudflarePineconeUpstashOpenAIDeepgramExaResendGoogleVercel
// What you stop doing

Zero per-vendor signups. Zero copy-pasted keys. One auth, one wallet, one subscription.

// See it work

It’s just HTTP. Call it from anywhere.

Every resource lives behind one edge endpoint and a bearer token. Same call, any runtime — no SDK lock-in, no client library to wait on.

# query your database over the edge — server-side curl -s -X POST https://cohesivity.ai/edge/database/query \ -H "Authorization: Bearer $SESSION" \ -d '{"sql":"SELECT * FROM users LIMIT 10"}'
const res = await fetch("https://cohesivity.ai/edge/database/query", { method: "POST", headers: { Authorization: `Bearer ${session}` }, body: JSON.stringify({ sql: "SELECT * FROM users LIMIT 10" }), }); const { rows } = await res.json();
import requests res = requests.post( "https://cohesivity.ai/edge/database/query", headers={"Authorization": f"Bearer {session}"}, json={"sql": "SELECT * FROM users LIMIT 10"}, ) rows = res.json()["rows"]
// The lifecycle

Ephemeral to claimed in three moves

01 — Ephemeral

Free, no signup

Genesis spins up a live backend with a 72-hour claim window. 20 Vercel deploys, 100 OpenAI requests, 5,000 database rows. Build, demo, throw it away. No card, no account.

→
02 — Claim

Sign in with Google

Sign in once before the window closes and the ephemeral tenant becomes yours. Paused hosted tenants auto-redirect to the claim URL — no manual credit babysitting like Emergent.

→
03 — Claimed

Free, Plus, or Pro

Unlimited projects, a monthly fluid grant, and real ceilings — 10M to 500M database rows. Razorpay-backed subscription and a fluid wallet. No credit-burning, just usage.

// Pricing

Start free with no signup. Claim when it’s real.

Ephemeral
Free

No signup. 72-hour claim window. Genesis and go.

  • 72-hour claim window
  • 20 Vercel deploys
  • 100 OpenAI requests
  • 50 Exa searches
  • 5,000 database rows written
  • 250 object storage uploads
  • 100 emails
Run genesis →
Claimed Free
$0

Claim with Google. Unlimited projects, real ceilings.

  • Unlimited projects
  • $5 / mo fluid grant
  • 10M database rows / mo
  • 500K Redis commands / mo
  • 10 GB object storage
  • 100K vector read units
  • 500K realtime messages / mo
Claim free →
Claimed Plus
$20 / mo

For builders shipping past the prototype.

  • $20 / mo fluid grant
  • 100M database rows / mo
  • 5M Redis commands / mo
  • 100 GB object storage
  • 10M vector read units
  • 30 Cloudflare Workers
  • higher AI rate limits
Go Plus →
Claimed Pro
$100 / mo

Max ceilings, max rate limits, max throughput.

  • $100 / mo fluid grant
  • 500M database rows / mo
  • 25M Redis commands / mo
  • 500 GB object storage
  • 50M vector read units
  • 100 Cloudflare Workers
  • max AI rate limits
Go Pro →
// The thesis

We took the Lightcone advice. We’re making something agents want.

The bet is simple: AI agents are about to write most of the backends, and they don’t want a console, a signup flow, or a key to paste. They want one endpoint and a token. So we built the raw Lego blocks of a backend — 14 services behind one HTTP API — and shipped them in 70 days. Three customers already pay for it. Masters Union switched off Emergent to use it. We built it like we already won. We’re just building anyway.

14
Services provisioned
70
Days old at launch
3
Paying customers
8,000+
Changelog lines

Stop wiring backends by hand.
Make something agents want.

$ curl -s -X POST https://cohesivity.ai/api/genesis > .cohesivity
Run the curl → Read the docs →