A Model API Gives You Tokens. Remy Ships a Running App.
A foundation-model endpoint returns text. Remy compiles a spec into a deployed full-stack app — backend, database, auth, frontend, tests, and hosting in one step.
A model endpoint returns text. Remy returns a deployed app.
Call a foundation-model API — OpenAI, Anthropic, Google — and you get tokens back. Maybe those tokens are code. You still own the next ten steps: standing up a database, wiring auth, building the frontend, writing tests, configuring deployment, and keeping it all running. Remy collapses all of that into one step. You describe the app in annotated markdown, and Remy compiles a complete, deployed full-stack application — backend, typed database, auth, frontend, tests, and hosting — that’s live at a URL.
That’s the gap between an LLM that writes code and a product agent that ships an app. The model is one ingredient. Remy is the kitchen, the recipe, and the plate.
At a glance
- Model API output: tokens. Remy output: a deployed full-stack app at a live URL.
- One step: spec → backend, typed database, auth, frontend, tests, deployment.
- Spec-driven: annotated markdown (MSFM) is the source of truth; code is compiled output.
- The infra layer: serverless SQL database, auth, atomic deployments, rollback — none of which a model endpoint provides.
- Integrations: 200+ AI model providers and 1,000+ external services, no separate API keys.
- One method, many interfaces: the same logic projects to web, REST API, Discord, Telegram, cron, webhook, email, and MCP.
- Recompile when models improve: the spec stays fixed; regenerate against a better model.
- Substrate proof: the platform underneath Remy powers production apps for The New York Times, ServiceNow, and HMRC.
Plans first. Then code.
Remy writes the spec, manages the build, and ships the app.
What does a foundation model actually give you?
A foundation model gives you a function: text in, text out. It’s a remarkable function. It can draft a React component, sketch a SQL schema, or explain an OAuth flow. But the output is text on your screen. Nothing is running.
To turn that text into a product, you become the integrator. You pick a database and provision it. You wire authentication and session handling. You scaffold a frontend and a build step. You write the deployment config, set up rollback, manage secrets, and stand up the monitoring. The model wrote some code; you built the application.
This is the work that doesn’t show up in a demo. It’s also the work that takes the most time, breaks most often, and never gets easier. A model endpoint hands you the easy 20% and leaves the durable 80% on your desk.
How is a product agent different from an LLM that writes code?
A coding assistant — Cursor, Claude Code, Copilot, Codex — generates code into your existing project. The output is files you commit. You still own the runtime, the database, the deployment, and every integration. A coding assistant makes you faster at building anything.
Remy is a product agent. It makes you very fast at building one specific, valuable shape of thing: a database-backed, multi-interface, role-gated app where every layer below the spec is already built and running. You describe the app. Remy writes the database tables, the backend methods, the frontend, and any integrations — as real TypeScript and React in a normal git repo — then compiles, builds, migrates, and deploys it.
The difference is where the work stops. A coding assistant stops at “here’s the code.” Remy stops at “here’s the running app.” We go deeper on this in coding agent vs product agent.
What does Remy compile that a model API can’t provide?
A model endpoint is a single capability: inference. An application needs a stack. Remy compiles the whole stack from one spec:
- Backend — TypeScript methods that run in isolated sandboxes, with an SDK for AI models, email, SMS, web scraping, and file handling.
- Database — a serverless SQL database with schema defined in TypeScript, auto-migrations, and per-release database clones.
- Auth — email and SMS verification codes, sessions, and role-based access control, opt-in per app.
- Frontend — a Vite and React scaffold, built on push and served from a CDN.
- Deployment — git-native, atomic releases with one-command rollback.
- Monitoring and analytics — request logs and built-in, queryable analytics.
- Integrations — 200+ AI model providers and 1,000+ external services, with no separate API keys to manage.
None of that comes out of a model endpoint. The endpoint is the inference inside the methods. Everything around it — the database, the auth, the deployment, the integration surface — is what Remy gives you that a raw API does not. Try Remy and you describe the product; the stack is the compile output.
Why is the spec the source of truth?
One coffee. One working app.
You bring the idea. Remy manages the project.
When a model writes code into your repo, the code is the artifact. Six months later, that code is the only record of what the app does, and it has drifted from anyone’s mental model of it.
Remy inverts that. The spec — annotated markdown, in a format called MSFM — is the source of truth. The backend, database, and interfaces are a compiled derivation of the spec, the same way .js is a compiled derivation of .ts. You change behavior by editing prose, not by hand-patching generated files.
This has a payoff that a model API can’t match: recompile when models improve. Your spec doesn’t expire. When a stronger model ships, you regenerate the same app against it — better generated code, same described product, no rewrite. The spec is the durable asset; the model underneath is swappable.
One method, many interfaces
Here’s something a model endpoint will never do for you, no matter how good the tokens are: project a single piece of business logic onto every channel at once.
In Remy, you write a method once — say, submitVendorRequest. That same method powers a web button, a REST endpoint, a Discord slash command, a Telegram bot, a cron job, an inbound webhook, an inbound email handler, and an MCP tool. The methods don’t know or care which interface invoked them. You don’t write eight integration shims; the compile step wires them.
Ask a model API for “a Discord bot and a web app and a cron job that share logic” and you’ll get three separate code samples and a long afternoon of plumbing. Remy compiles them from one description.
How does Remy compare to other AI builders on capability?
Bolt, Lovable, v0, Replit, Cursor, and Claude Code are all good tools. They differ from Remy on what comes out the other end. The honest comparison is about the deployed artifact, not anyone’s roadmap.
| Tool | Primary output | Ships a backend | Ships a database | Ships auth | Deployed and running |
|---|---|---|---|---|---|
| Foundation-model API | Tokens / code snippets | No | No | No | No |
| Cursor / Claude Code / Copilot | Code into your repo | Only what you wire | Only what you wire | Only what you wire | You deploy it |
| v0 | UI components | No | No | No | Frontend preview |
| Bolt / Lovable | Frontend app | Partial | Via add-on | Via add-on | Frontend hosted |
| Replit | App in an IDE | Yes | Yes | You wire it | You configure it |
| Remy | Deployed full-stack app | Yes | Yes (typed, migrated) | Yes (opt-in) | Yes, at a live URL |
The pattern: most AI builders are excellent at the frontend and the demo. Remy’s job is the part after the demo — the backend, the typed database with real migrations, the auth, and the deployment that keeps it live. For a deeper side-by-side, see what is Remy.
What kind of work is Remy built for?
Remy is built for database-backed apps where logic correlates with human action: internal tools, vertical SaaS, approval workflows, CRM-shaped apps, research dashboards, monitoring tools. These are apps with real users, real auth, and real data that needs to survive a deploy.
The platform underneath Remy is not new. It powers production applications for The New York Times, ServiceNow, and HMRC. Remy is the product-agent layer on top of that hardened substrate — which is why “compile a spec into a deployed app” isn’t a demo trick. The deployment, the per-release database clones, and the atomic rollback are the same machinery those production apps run on.
What is Remy?
Remy is a product agent that compiles annotated markdown into a full-stack app — backend, database, frontend, auth, tests, and deployment — in a single step. See goremy.ai.
The shortest way to say it: a model API gives you tokens. A coding assistant gives you code. Remy gives you a running application. If you want to describe an app and get back something that’s live at a URL, that’s the difference that matters.
FAQ
What does Remy compile from a spec?
A complete full-stack app: a TypeScript backend, a typed serverless SQL database with auto-migrations, opt-in auth with email and SMS verification, a Vite and React frontend, tests, and a deployment. It’s all generated from annotated markdown in one step.
What does Remy deploy, exactly?
A running application at a live URL. The compile pipeline parses your manifest, builds the methods and frontend, diffs and migrates the database against a clone, then atomically promotes the release. Rollback restores the previous release’s code and data together.
How is Remy different from a foundation-model API?
A model API returns tokens — including code, if you ask. It doesn’t give you a database, auth, a frontend build, or a deployment. Remy uses the model for inference inside your methods and compiles everything around it into a deployed app.
How is Remy different from a coding assistant like Cursor or Claude Code?
A coding assistant writes code into your existing project; you still own the runtime, database, deployment, and integrations. Remy generates the code and runs it — every layer below the spec is built and hosted for you.
How does the spec work as a source of truth?
You write the app as annotated markdown (MSFM). The backend, database, and interfaces are compiled output, the way .js is compiled from .ts. When models improve, you recompile the same spec against a better model instead of rewriting the app.
Does Remy work across multiple interfaces?
Yes. One method projects to web, REST API, Discord, Telegram, cron, webhook, email, and MCP without writing separate integration code. The methods don’t know which interface invoked them.
How does Remy compare to Bolt, Lovable, v0, and Replit on capability?
Those tools are strong at the frontend and the demo. Remy’s focus is the full stack that survives past the demo: a typed database with real migrations, opt-in auth, and a git-native deployment with atomic rollback. The comparison table above breaks it down by output.
What’s Remy best suited for?
Database-backed apps where work correlates with human action — internal tools, vertical SaaS, approval workflows, CRM-shaped apps, and research or monitoring dashboards.
