Remy: The Product Agent That Compiles Specs Into Full-Stack Apps

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. You describe what you want to build. Remy generates a spec, writes the code, tests it in a real browser, and ships it to a live URL. The spec is the source of truth. The code is compiled output.

Remy runs on infrastructure that powers applications for The New York Times, ServiceNow, and HMRC. It’s open source, with five public repositories on GitHub. You can try it at goremy.ai.

At a Glance

• What it builds: Full-stack TypeScript apps with SQL databases, auth, frontends, APIs, and deployment
• How it works: Six specialist sub-agents (design, browser automation, code sanity, product vision, conversation summarizer, brand extractor) collaborate to generate a spec, compile it into code, test it, and ship it
• Source of truth: MSFM (MindStudio-Flavored Markdown)—annotated prose that both humans and agents can read
• Open source: Five repos under github.com/mindstudio-ai
• Built on: The MindStudio platform substrate—200+ AI models, 1,000+ integrations, managed databases, auth, and deployment
• Deployment: Git-native; git push triggers build and deploy to production
• Cost: Pay only for inference during the alpha (no platform fees); a typical full-stack app costs $30-40 to build

How Does Remy Work?

Remy isn’t a chatbot that writes code snippets. It’s a compiler. You start with a conversation—voice, text, or a pasted document. Remy asks clarifying questions, aligns on what you’re building, then generates a spec. That spec is annotated markdown: readable prose that describes the app, plus structured annotations that carry precision (data types, validation rules, edge cases, code hints).

Once the spec is ready, Remy compiles it. Six specialist sub-agents handle different parts of the build:

1. Design agent — picks fonts, generates images, writes CSS, ensures visual consistency
2. Browser automation agent — drives a real browser to test user flows, catch broken links, verify auth works
3. Code sanity agent — reviews generated code for bugs, security issues, and adherence to the spec
4. Product vision agent — maintains narrative coherence across the build, ensures features align with the stated goal
5. Conversation summarizer agent — compacts context when conversations get long, preserves key decisions
6. Brand extractor agent — pulls brand identity (colors, tone, logos) from URLs or documents you provide

The output is a working application: TypeScript backend methods, a serverless SQL database with typed schemas, a Vite + React frontend (or any framework you specify), email/SMS verification codes for auth, role-based access control, and a deployed URL. The whole process—from first message to live app—takes anywhere from 10 minutes to an hour depending on complexity.

What Does Remy Actually Generate?

Every Remy build produces six deliverables:

1. The spec — MSFM document in src/, the source of truth for the application
2. Backend contract — TypeScript methods in dist/, compiled from the spec
3. Database schema — Typed SQL tables with migrations
4. Frontend — React app (or another framework) with routing, state management, API calls
5. Auth system — Verification codes (email/SMS), sessions, roles, opt-in by default
6. Deployment config — Git-backed pipeline; every push to main triggers a build and deploy

The code lives in a git repo. You own it. You can edit it by hand, extend it with any npm package, or update the spec and recompile. The spec stays in sync with the code through a bidirectional sync process—change the spec and the code updates, or change the code and Remy updates the spec to match.

What Is MSFM?

MSFM stands for MindStudio-Flavored Markdown. It’s the spec format Remy compiles. Think of it as a programming language that looks like annotated prose instead of syntax with semicolons.

A typical MSFM spec has two layers:

• Readable prose — describes what the app does in plain English
• Structured annotations — inline YAML blocks that define tables, methods, roles, interfaces, validation rules

Example:

## User Management

Users sign up with email verification codes. Once verified, they can create projects.

```yaml
table: users
fields:
  - name: email
    type: string
    unique: true
  - name: verified
    type: boolean
    default: false

This is a new kind of programming. The abstraction layer moved up. You’re not writing TypeScript—you’re describing the application, and the TypeScript is derived. As AI models improve, the compiled output improves automatically. You don’t rewrite the app. You recompile it.

What Is Remy Built On?

Remy is built on the MindStudio platform substrate—the same infrastructure that powers production applications for The New York Times, ServiceNow, HMRC, and others. That substrate gives Remy 200+ AI models, 1,000+ integrations, managed databases, auth, and deployment out of the box.

Remy is the product-agent layer on top of that hardened platform. The substrate handles the hard infrastructure problems—sandboxing, database hosting, auth, deployment—so the agent can focus on one thing: compiling a spec into a working full-stack app. The primitives Remy compiles against (MSFM, the manifest, methods, tables, roles) were developed on that platform and are now the foundation Remy builds on.

Is Remy Open Source?

Yes. Five repositories are public on GitHub under github.com/mindstudio-ai:

1. remy — the agent itself (tool-use loop, sub-agents, prompt machinery)
2. mindstudio-agent — backend SDK (@mindstudio-ai/agent)
3. mindstudio-interface — frontend SDK (@mindstudio-ai/interface)
4. mindstudio-local-model-tunnel — local dev environment CLI

The code is readable, well-documented, and actively maintained. You can fork it, extend it, or run it locally. The runtime (the platform that executes compiled apps) is not open source—it’s the infrastructure layer that handles sandboxing, database hosting, auth, and deployment. But the agent, the SDKs, and the dev tooling are all public.

How Is Remy Different From Coding Agents Like Cursor or Claude Code?

Coding agents help you write and edit code faster within an existing codebase. You chat with them about files, functions, and bugs. They suggest edits, generate boilerplate, refactor methods. Claude Code Dispatch and Cursor are excellent at this.

Remy works at a different layer. You’re not editing TypeScript line by line. You’re defining what the app does in a spec, and the code is compiled from that. The spec is the source of truth. The code is derived. When you want to change something, you update the spec and recompile—or you chat with Remy and it updates the spec for you.

For building new full-stack apps from specs, use Remy. For editing existing codebases, use a coding agent.

How Is Remy Different From AI App Builders Like Lovable or Bolt?

Tools like Lovable, Bolt, and Replit Agent are prompt-driven code generators. You chat with them, they emit code. The source of truth is a chat log of prompts, not a structured spec.

Remy is spec-driven compilation. The spec is the source of truth. The code is compiled output. That difference holds even as competitors add more features. When you want to change something, you update the spec and recompile. When AI models improve, your app improves on recompile without rewriting prompts.

The spec layer is what makes iteration reliable over time. It’s not a chat log. It’s a structured document that both you and the agent can reason about.

What Can You Build With Remy?

Remy is designed for full-stack web applications. Internal tools, vertical SaaS prototypes, CRMs, approval workflows, content management systems, AI-powered apps with image generation or autonomous agents built in. Anything that needs a backend, a database, and a frontend.

What works well:

• Internal tools (vendor approval systems, dashboards, admin panels)
• Vertical SaaS prototypes (industry-specific workflows with custom data models)
• AI-native apps (apps that generate images, process documents, run autonomous agents)
• Multi-interface apps (web + REST API, web + Discord bot, web + Telegram, web + email)

What doesn’t work yet:

• Native mobile apps (mobile-responsive web apps work fine)
• Real-time multiplayer with persistent WebSocket connections (turn-based and async multiplayer work)
• Apps that need sub-100ms latency for every request (the runtime is fast, but not that fast)

The Debut gallery shows real apps built by alpha users. Browse it to see what’s possible.

How Efficient Is Iteration With Remy?

Because the spec is the source of truth, iteration is cheap by design. When you change something, the agent recompiles only what changed—it doesn’t rebuild the whole app from scratch. Update a table, add a method, change a role, and Remy compiles the delta.

This is why the spec-driven model matters for ongoing work. You’re not re-prompting an entire app into existence every time. You edit the spec, recompile, and the rest stays stable.

What Models Does Remy Use?

Remy is model-agnostic. It uses the best available models for each job. Today that means:

• Claude Opus for the core agent (reasoning, planning, tool use)
• Claude Sonnet for specialist sub-agents (faster, cheaper, still capable)
• Seedream for image generation
• Gemini for image analysis

This will change as models evolve. The spec-as-source-of-truth architecture means better models produce better compiled output without changing your app. You don’t rewrite anything. You recompile.

Remy also supports local models and custom model endpoints if you want to bring your own infrastructure. For teams exploring open-weight models for agentic workflows, the local dev CLI lets you test against your own endpoints.

How Does Deployment Work?

Remy apps are git-native. Every app is a git repo. When you push to the main branch, Remy triggers a build: compiles the spec, runs tests, deploys to production. Atomic releases. Instant rollback if something breaks. Per-release database cloning so you can test migrations safely.

You can set custom subdomains via the CLI. Custom apex domains are coming soon. Apps are hosted on the MindStudio platform substrate—the same infrastructure that runs production apps for The New York Times and ServiceNow. It’s fast, reliable, and scales automatically.

What About Auth and Security?

Auth is opt-in and built into every Remy app by default. Email or SMS verification codes. Cookie-based sessions. Role-based access control. You define roles in the spec (admin, user, viewer, etc.) and Remy enforces them at the method level.

Secrets (API keys, Stripe keys, OAuth credentials) are encrypted at rest and injected as process.env variables. Separate dev and prod values. The CLI manages them.

SSO/SAML/OAuth integrations are on the roadmap for GA. The alpha is focused on prototypes and internal tools, not enterprise sales.

Can You Edit the Code Remy Generates?

Yes. The code lives in a git repo. You own it. You can edit it by hand, add npm packages, extend methods, change the frontend framework. The dist/ folder contains the compiled contract (backend methods, database schema). The src/ folder contains the spec.

If you edit the code, you can sync the spec to match by clicking the sync button in the editor. Or you can edit the spec and recompile. Bidirectional sync keeps the two in alignment.

The recommended workflow: update the spec, recompile. That way, as models improve, your app improves automatically. Hand-editing the code works, but you lose the recompile benefit.

What’s the Relationship Between Remy and MindStudio?

Remy is built on the MindStudio platform substrate. That substrate—200+ AI models, 1,000+ integrations, managed databases, auth, and deployment—is what Remy runs on, and it’s the same infrastructure that powers production applications for major enterprises.

Remy is the product-agent layer on top of that infrastructure. The platform handles the hard infrastructure problems; Remy handles compiling a spec into a working full-stack app.

If you see references to “MindStudio” in the developer docs or the open-source repos, that’s the platform foundation. The primitives (MSFM, the manifest, methods, tables, roles) were developed on the MindStudio platform and are now the foundation Remy compiles against.

Who Should Use Remy?

Remy is for people who want to build and ship full-stack applications without spending weeks wiring up infrastructure. Product managers who can describe what they need but don’t want to write backend code. Founders who need an MVP fast. Operators who need internal tools yesterday. Technical users who want to prototype at a higher level of abstraction.

It’s also for developers who are curious about what programming looks like when the source language is annotated prose instead of TypeScript. If you’ve ever thought “I wish I could just describe what I want and have the code follow,” Remy is that.

Remy is not for people who need sub-100ms latency, real-time multiplayer, or native mobile apps. It’s not for teams that need enterprise SSO today (it’s coming, but not in the alpha). And it’s not for people who want to edit every line of generated code by hand—if that’s your workflow, a coding agent like Cursor or Claude Code Dispatch is a better fit.

How Do You Get Started?

Go to goremy.ai. Remy is in open alpha. Sign up, describe what you want to build, and Remy will ask questions, generate a spec, compile it into a working app, test it, and deploy it. The whole process is in the browser. No setup tax. No local environment to configure.

Once you’re in, the fastest way to learn is to build something. Pick a small internal tool or a simple app idea. Watch Remy work. See what it generates. Iterate on the spec. Deploy it. Then come back and build something bigger.

FAQ

How do I get access to Remy? Remy is in open alpha. Sign up and start building at goremy.ai.

What does Remy cost? During the alpha, there are no platform fees—you pay only for inference costs, the raw AI model usage, with no markup. A typical full-stack app costs $30-40 to build from scratch; more complex apps with many features might cost $100-150. Iteration costs less because the agent only recompiles what changed.

Can I use Remy for production apps? Yes. Apps run on production infrastructure used by The New York Times and ServiceNow. The product is still in alpha, so bugs and feature changes happen, but the runtime is production-grade.

What happens to my data? You own it. Your code lives in a git repo. Your database is yours. Remy is infrastructure, same as GitHub or Vercel. The platform hosts and runs your app, but you own everything in it.

Can I export my app and run it elsewhere? The code is yours and mostly portable (TypeScript, React, SQL). The runtime (sandboxing, database hosting, auth, deployment) is not portable—it’s the platform layer. If you want to move off Remy, you’d need to reimplement that infrastructure yourself. The spec and the code are yours to take.

Does Remy work with local models? Yes. The local dev CLI supports local models and custom endpoints. You can run Remy against your own infrastructure if you want.

What if I find a bug? Use the “Send Feedback” button in the UI or email sean@mindstudio.ai. The team can’t promise fast turnarounds during the alpha, but they want to hear about it.

Can I collaborate with others on a Remy app? Not yet. Multi-user collaboration is on the roadmap. For now, it’s one user per app.

What frameworks does Remy support? Backends are TypeScript (any npm package works). Frontends default to Vite + React, but you can specify another framework and Remy will adapt. The only requirement is that the frontend can run a build command.

Can Remy build mobile apps? Not native mobile apps. Mobile-responsive web apps work fine. Native iOS/Android is not supported.

How does Remy stay useful as AI models improve? The spec is the source of truth; code is compiled output. When models improve, you recompile and the app upgrades automatically. You don’t rewrite anything. The spec-driven architecture means better models produce better apps without changing your source.

How does Remy compare to other AI agents? Remy is a product agent, not a coding agent or a task agent. It compiles specs into full-stack apps. Most other AI agents for product managers are either code-editing tools (Cursor, Claude Code) or task-automation tools (OpenClaw, Hermes). Different categories, different jobs.

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.

Start building with Remy →