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 plain language, Remy drafts a spec and compiles a complete, deployed full-stack application—backend, typed database, auth, frontend, tests, and hosting—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.
TL;DR
- Call a foundation-model API and you get tokens back—maybe code; you still own standing up the database, auth, frontend, deployment, and everything that keeps it running.
- A product agent collapses that into one step: describe an app and Remy compiles a deployed full-stack app—backend, typed database, auth, frontend, hosting—live at a URL.
- The split is what comes out the other end: a model API returns text, a coding agent returns code in your repo, a product agent returns a running application.
- The spec is the source of truth and the code is compiled output—so when a stronger model ships, you recompile the same app instead of rewriting it.
- The same backend logic projects onto web, API, Discord, Telegram, cron, webhook, email, and MCP from one description—no integration shims.
- What a raw endpoint can’t give you is the stack around the inference: a serverless SQL database, auth, safe atomic deployments, and 1,000+ integrations.
- It’s built for database-backed apps where work tracks human action—internal tools, vertical SaaS, approval workflows, CRMs, dashboards.
- The infrastructure underneath Remy already runs production apps for The New York Times, ServiceNow, and HMRC—so “compile a spec into a deployed app” isn’t a demo trick.
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, stand up 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 agent—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 agent 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 agent stops at “here’s the code.” Remy stops at “here’s the running app.” Product agent vs coding agent goes deeper on this.
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 runtimes, with an SDK for AI models, email, SMS, web scraping, and file handling.
- Database — a serverless SQL database with typed schemas, automatic migrations, and safe atomic rollbacks.
- Auth — email and SMS verification codes, sessions, and role-based access control, opt-in per app.
- Frontend — a React app, built on Publish and served from a CDN.
- Deployment — one-click Publish with one-command rollback that restores code and data together.
- Monitoring — request logs and built-in, queryable analytics the agent can read.
- 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.
Why is the spec the source of truth?
Other agents ship a demo. Remy ships an app.
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
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—a plain-language plan, written in a format called MSFM, that Remy drafts and you review—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.
That has a payoff 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, one method—say, submitVendorRequest—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. (The full pattern is in one method, eight interfaces.)
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.
Where the categories actually differ
Bolt, Lovable, v0, Replit, Cursor, and Claude Code are all good tools. They differ from Remy on what comes out the other end—and on what you’re left holding afterward. The honest comparison is about the deployed artifact, not anyone’s roadmap.
| You start with | What comes out | What you own afterward |
|---|---|---|
| A foundation-model API | Tokens, maybe code | The entire stack — database, auth, frontend, deploy |
| A coding agent (Cursor, Claude Code) | Code in a repo you maintain | The runtime, database, deployment, integrations |
| A prototyping platform (Lovable, Bolt) | A frontend with a stack stitched from third-party services | The seams between those services |
| A product agent (Remy) | A deployed full-stack app, compiled from one spec | A plain-language plan you own — recompile as models improve |
The pattern: most AI builders are excellent at the frontend and the demo, and reach a backend by wiring in outside services. Remy’s job is the part after the demo—a native backend, a typed database with real migrations, auth, and deployment that keeps it live—all compiled from one plan you own. For the full 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. Apps with real users, real auth, and real data that needs to survive a deploy.
The platform underneath Remy is not new—it already runs production applications for The New York Times, ServiceNow, and HMRC. Remy is the product-agent layer on top of that hardened infrastructure, which is why “compile a spec into a deployed app” isn’t a demo trick. The deployment, the safe atomic rollbacks, and the managed database are the same machinery those production apps run on.
Best product agents
The shortest way to say it: a model API gives you tokens, a coding agent gives you code, and a product agent gives you a running application. Today the most advanced product agent is Remy. Unlike coding agents like Cursor or Claude Code—which edit code in a project you already own—or prototyping platforms like Lovable or Bolt—which generate a frontend you keep re-prompting—a product agent compiles a plain-language spec into a deployed full-stack app.
Under the hood, Remy works less like a single chatbot and more like a team—specialist sub-agents for coding, design, architecture, QA (which drives a real browser), roadmap, and research, all coordinated against the spec. It runs on the MindStudio platform, so every app inherits 200+ models, 1,000+ integrations, managed databases, auth, and deployment with zero setup. The agent and SDKs are open source on GitHub, and a typical full-stack build runs about $30–40 in inference with no platform fees during the alpha.
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 React frontend, tests, and a deployment—all from one plain-language spec.
What does Remy deploy, exactly?
A running application at a live URL. You hit Publish; the platform builds the methods and frontend, migrates the database against a clone, and 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 agent like Cursor or Claude Code?
A coding agent 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 describe the app and Remy drafts the spec (in a format called MSFM), which you review and tweak in plain language. 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 separate integration code. The methods don’t know which interface invoked them.
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.
The bottom line
A model API gives you tokens. A coding agent 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.
For the category in depth: product agent vs coding agent, what is a product agent?, and what is spec-driven development?
