Full-stack apps coding agents can ship.
One TypeScript model — schema, policies, server functions, typed clients — and Pylon wires in live sync, auth, storage, jobs, and one-binary deploy over SQLite or Postgres. You build the product, not the plumbing.
Give agents a system they can inspect.
Pylon keeps rules, commands, generated types, local data, and logs inside the workflow. Your agent can scaffold, run, debug, and deploy without guessing which console owns the next step.
Rules live in the repo
New apps include AGENTS.md, and the Pylon skill installs with npx skills add pylonsync/pylon. The agent reads the conventions before it edits code.
The path is command-line
npm create @pylonsync/pylon scaffolds the app. pylon dev runs it locally. pylon deploy ships it to Cloud.
Generated types catch drift
pylon codegen builds the client from your schema and functions. Bad entity names, missing fields, and wrong arguments fail at compile time.
Runtime state is visible
The agent can inspect tables, live queries, and logs in /studio while pylon dev runs. Debugging happens against current data.
Your app model stays in TypeScript.
Declare an entity and its access policy. Pylon creates the table, REST and realtime API, row-level checks, and typed React client. No resolvers, ORM layer, or separate backend service to keep in sync.
The backend pieces ship together.
Schema, sync, auth, functions, storage, search, jobs, rooms, and SSR share one schema and one runtime. Pick the pieces your app needs and ship them as one binary.
Typed schema
Define entities, fields, and indexes in TypeScript. Pylon turns them into tables and applies migrations on save.
Live queries
db.useQuery opens a WebSocket subscription. Every write pushes a diff to subscribed clients, without polling or cache invalidation.
Reactive server queries
Write query() for joins and derived data. The server tracks what it read and re-runs when those dependencies change.
Server functions
Put queries, mutations, and actions in TypeScript files with v.* validators. React calls them through the typed client.
Row-level policies
Access rules live next to the schema as expressions like auth.userId == data.authorId. Every read and write is checked; default deny.
Auth, included
Magic-link email, 25+ OAuth providers, generic OIDC discovery, guest sessions, and API keys are built in.
SQLite or Postgres
Start with SQLite in one file. Set DATABASE_URL=postgres://... and the same schema targets Postgres.
Admin studio
Browse tables, inspect live queries, tail logs, and run ad-hoc mutations at /studio. Admin-gated in prod.
File uploads
Use presigned uploads. Store files on local disk or an S3-compatible bucket such as R2, Backblaze, or MinIO.
Faceted search
Add search to an entity for full-text queries, live facet counts, and sort. Search updates in the same transaction as your writes.
Scheduled & deferred work
Schedule follow-up work with ctx.scheduler.runAfter, runAt, and cancel. Delays and retries run in the same process.
Rooms & presence
WebSocket rooms with live presence over the same server — broadcast ephemeral state (cursors, typing, who's online) without a separate realtime service.
Deploy from GitHub or the CLI.
Connect GitHub
Install the Pylon Cloud GitHub App once. Pushes to the default branch deploy; pull requests get previews that disappear after merge.
1.Create a project and connect a repo.
2.git push origin main triggers a deploy.
3.Live at your-app.pyln.dev.
pylon deploy
Use the CLI for CI, locked-down environments, or a manual release. It reaches the same Cloud runtime as the GitHub flow.
Scale from one dashboard.
Every app sits behind a global edge network, with resize, replicas, regions, and storage a click away from where you deploy. No pre-provisioning. No per-seat pricing.
Global edge network
Every app sits behind Cloudflare's edge — CDN caching, TLS, and DDoS protection worldwide, with nothing to configure.
Resize on demand
Add RAM up to 64 GB, choose performance CPUs, and expand the volume without redeploying.
Replicas
Run up to 32 load-balanced replicas per region on Pro.
Global regions
Deploy in US, EU, APAC, and South America regions.
Up to 500 GB volume
Grow storage live when the app needs room.
Managed Postgres — private beta
Bundled SQLite by default; co-located managed Postgres is in private beta.
Autostop on idle
Free tier sleeps when idle. Paid projects stay warm.
Custom domains + TLS
Bring your domain; Pylon handles TLS.
SSO — OIDC + SAML
Configure org-level SSO from the dashboard.
Audit log + snapshots
Activity log, one-click volume restore.
Where you’ll push back.
You don’t hand your whole stack to a framework on faith. So here are the four questions we’d expect from you, answered straight — then open the repo and judge for yourself.
Why wouldn't I just build this myself?
You could — you've built each piece before: the schema and migrations, the row-level access checks, the session handling, the REST endpoints, the socket that pushes live updates, the generated client. The work isn't the hard part; it's that all of them have to agree, and they stop agreeing the day the schema moves. Pylon generates the whole set from one entity and its policy and regenerates them together on every change. What you buy back is the afternoon you'd otherwise spend re-syncing them by hand.
Doesn't a framework lock me in?
Your code does import Pylon's SDK — that's real, and it's the trade: one typed model in place of six services you wire together yourself. But the runtime is a single open-source binary you host, sitting on ordinary SQLite or Postgres. There's no proprietary datastore to escape — take a plain dump, or run the whole platform on your own box with no account. The lock-in worth fearing is a cloud engine you can't self-host. Pylon isn't one.
Is "agent-native" just marketing?
It's a concrete set of affordances: the rules, commands, generated types, local data, and logs all live in one workflow an agent can drive end to end — scaffold, run a migration, read the failure, redeploy — without hopping between four consoles. Run npm create @pylonsync/pylon and watch an agent take it from empty folder to running app. That's the claim, and it's testable.
What happens when I outgrow it?
There's no starter abstraction to graduate from. The runtime is Rust on Postgres — the same engine you'd move to anyway — so scaling is turning on Postgres mode, adding replicas, and leaning on the edge that already fronts every app, with your code untouched. The migrations that hurt are the ones where a starter backend runs out of room; Pylon doesn't ship one for you to outgrow.
Pricing you can start with.
Start with one free project. Pro is $25 per org per month; heavier compute, replicas, and storage bill as usage.
One project for weekend builds and your first users.
✓1 project, 1 organization
✓Shared 1 GB RAM · 3 GB volume
✓100k requests / month
✓Single region, autostop on idle
✓SQLite, magic-link auth
Production apps with room to grow. Resize machines, add replicas, expand regions.
✓Unlimited projects per org
✓Resize up to 64 GB · 32 replicas / region · 500 GB volume
✓5M requests / month included
✓Multi-region, always-warm
✓Custom domains, SSO, audit log, snapshots
Bespoke quotas, single-tenant, BYOC. For larger teams.
✓Custom quotas + dedicated infra
✓Single-tenant or BYOC (AWS, GCP)
✓Custom regions on request
✓SLA + on-call escalation
✓Migration assistance, security review
Pro is $25/org/month. Bigger machines, more replicas, and larger volumes are billed at the underlying compute rate for what you run. Or self-host the open-source framework anywhere — Pylon is one binary.
Create a Pylon app.
No card for Hobby. Connect GitHub or deploy from the CLI when you are ready.