10 Real Apps Built on Remy — and What Each One Reveals
A guided tour of 10 apps from the Debut gallery — the public showcase of full-stack apps people have shipped on Remy — and what each one reveals about the architecture.
What is the Remy Debut gallery, and why does it matter?
The Remy Debut gallery at debut.msagent.ai is the public showcase of full-stack apps people have shipped on Remy during the open alpha. Travel recap apps. Short-term rental dashboards. VC due-diligence tools. Family command centers. Spaced-repetition study apps. Small games. Each entry is a real, deployed app with a real backend, a real database, real auth, and a real URL, not a prompt-to-demo screenshot.
This post walks through 10 representative apps from that gallery, naming what each does, what category it lives in, and what it reveals about Remy as a product agent. The point isn’t to argue Remy is the best builder in the category. The point is that “show me real examples of AI-built apps” has a verifiable answer, and the answer lives at a URL you can open right now.
TL;DR
- The Debut gallery is a public showcase of full-stack apps people shipped on Remy: real deployed apps on real URLs, not prompt-to-demo screenshots.
- The apps span internal tools, vertical SaaS, consumer apps, civic tools, fund operations, and small games, the full shape-space a product agent targets.
- Every app shares the same anatomy: a serverless SQL database, backend methods, a real frontend, and auth with verification codes, all compiled from one plain-language spec.
- The recurring pattern is multi-entity relational schemas (properties→bookings→tasks, clients→projects→deliverables), the depth where prototype-grade builders fall apart at the second feature request.
- Background work is first-class: scheduled jobs and agent-driven tasks compile into the deployment, not into a “TODO: add a worker later.”
- The same backend methods can be reached from web, Discord, Telegram, MCP, and cron: one spec, many front doors.
- A typical full-stack build runs about $100 in inference, on top of Remy’s $99/month subscription ($79 annual, 7-day free trial).
- You can verify all of it yourself. The gallery is public and the apps are deployed, so open the URLs.
Remy doesn't write the code. It manages the agents who do.
Remy runs the project. The specialists do the work. You work with the PM, not the implementers.
Why these 10 apps?
The Debut gallery skews toward what real people decide to build when nobody’s grading their idea: serious business tooling next to personal projects next to civic tools next to toy games. The 10 below are picked for breadth. They span the major application shapes Remy targets and the architectural patterns the spec format supports.
For each app: the name and a one-line description, the category, and what the build reveals about Remy at the architecture layer. Individual builders aren’t quoted by name. Debut entries are public, but the people behind them haven’t all opted into being profiled. The apps themselves are fair game.
What kinds of apps can you build with Remy?
The honest answer: any app shape where a spec is a reasonable starting point and writes correlate with human action rather than machine bursts. The 10 below cover most of that shape space.
1. Trippo — a travel recap app
Category: consumer / personal
What it does: You upload photos and locations from a trip. Trippo generates AI-written recaps for each day and assembles a polished, shareable trip page with a real URL.
What it reveals: File uploads compiled into a typed database column. AI text generation as a first-class method call inside the backend, not a frontend afterthought. A public share-by-URL pattern that compiles to a real route, not a query-string demo. This is the shape of consumer app that prototype-first generators usually deliver as a mockup and call done. Trippo is a real frontend on a real backend with a real persistence layer.
2. Lumina — short-term rental operations
Category: vertical SaaS / hospitality
What it does: Tracks listings, bookings, cleaning schedules, and revenue across multiple short-term rental properties, built by a single operator running properties, not a SaaS company.
What it reveals: A multi-entity relational schema (properties, units, bookings, guests, tasks) modeled as typed SQL tables, not JSON blobs. Multi-user authentication and role gating. This is the application shape that most “no-code” tools choke on once you cross three or four related tables. It’s the kind of app a vertical SaaS company would charge $80–150 per property per month for, compiled here from a single spec, for the cost of inference, by the operator who actually runs the properties.
3. Ready-to-Foundry — VC due diligence
Category: professional services / financial
What it does: Helps an investor structure due-diligence workflows on prospective portfolio companies: collecting artifacts, tracking diligence questions, ranking companies against a checklist.
What it reveals: Form-heavy data capture compiled into typed input methods. A workflow with stages, statuses, and assignments, the bread and butter of internal ops tools. AI-generated summaries layered over collected data. The spec for this kind of app reads like a structured checklist with prose; the compiled output is a multi-page web app with auth, role-based views, and persistence.
4. ClientNest — agency / consulting client management
Category: internal tools / professional services
What it does: A small consultancy’s internal hub for tracking clients, projects, deliverables, and invoices.
Other agents ship a demo. Remy ships an app.
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
What it reveals: Role-gated views: partners see one thing, account managers another, contractors only their assignments. A custom subdomain (every Remy app gets one). The “internal tool that would have been a Retool deployment or a Bubble app” pattern, compiled from a markdown spec instead of dragged together in a visual editor. The honest comparison isn’t to Retool’s features. It’s to Retool’s cost and the time to first deploy.
5. A family command center
Category: personal / consumer
What it does: A shared household app: chores, meal plans, schedules, kids’ assignments, grocery lists. Each family member has a role; some views are private, some shared.
What it reveals: Multi-user auth with verification codes. Role gating without writing auth middleware. The app shape almost nobody builds, because configuring an auth provider plus a database plus a deployment plus a domain for “my family’s chores” doesn’t pencil out, until the whole stack collapses into a markdown spec. The punchline: a builder spends about $100 in inference for an app that competes with category-leading household apps charging $5–10 a month forever, compiled from a single spec by the person who actually uses it.
6. A civic tool — local zoning lookup
Category: civic / public information
What it does: Takes municipal zoning data and exposes it through a public-facing app: search by address, see allowed uses, get a structured summary.
What it reveals: Public read-only routes alongside authenticated admin routes. Data ingestion from external sources compiled into a typed database. A small civic app shape that’s been built and rebuilt by city governments at six-figure consulting costs. Here it’s a markdown spec, a typed schema, and a ~$100 inference bill.
7. A fund deal-tracking app
Category: financial / institutional
What it does: A pipeline tracker for a fund’s deal flow: companies, stages, partners assigned, notes, follow-ups, projected returns. Adjacent to Ready-to-Foundry, but built for use inside a fund rather than for diligence on companies.
What it reveals: The shape of an enterprise CRM, compiled from one spec. Strict role gating. Audit-style note history. A custom domain. Integrations with external services through Remy’s curated action library. Deal-tracking is well-trafficked in the gallery because it’s what every PM, GP, and ops person has thought about building in a spreadsheet first.
8. Mission Control — spaced-repetition study app
Category: education / personal
What it does: A study app for memorizing structured content. The pattern transfers to medical terminology, language vocabulary, legal statutes, anything you need to learn cold.
What it reveals: Scheduled methods (cron jobs): review prompts that fire on a spaced-repetition interval. AI text generation for hints and clarifications. A daily-use, mobile-responsive interface. This is the spec pattern most prototype-first builders can’t compile, because they don’t expose background jobs as first-class primitives. Remy compiles the scheduler into the deployment, not into a TODO file.
9. Goblin Run — a small game
Category: consumer / games
What it does: A small mobile-responsive game, the kind of thing a designer ships in a weekend because they can.
What it reveals: Remy isn’t a game engine, but the gallery includes games anyway, because the shape of a “score, leaderboard, daily challenge, accounts” app compiles cleanly from a spec. The point here is range: Remy was built for internal tools and full-stack consumer apps, and the spec language is general enough that small games come along for the ride. Turn-based and async play fit comfortably; real-time multiplayer with persistent WebSockets is a different shape, better served by a purpose-built engine.
10. An agent-interface app
Category: AI tools / agent
What it does: An app whose primary interface isn’t a web UI but a Discord bot, a Telegram bot, an MCP server, or a programmatic API. The same backend methods power all of them.
What it reveals: Multi-interface deployment. One spec, one set of backend methods, multiple front doors: web, Discord, Telegram, MCP, cron. This is one of the architectural patterns specific to Remy: the interface layer is genuinely orthogonal to the methods layer, in a way most app frameworks don’t compile to natively.
What does a Remy app actually look like once it’s deployed?
Every Remy app, whatever its category, has the same underlying anatomy:
- A typed serverless SQL database, isolated per app
- Backend methods written in TypeScript, callable from any interface
- A real frontend (React by default; the spec can call for something else)
- Real auth with verification codes and sessions
- A real URL (a Remy-issued subdomain, with optional custom domain)
- A live admin dashboard for users, secrets, logs, and the production database
- A roadmap of next features the agent proposes, and a pitch deck it generates for the app
That’s the deliverable for every Debut entry: Trippo, Lumina, ClientNest, the family command center, Mission Control, the fund deal tracker. Same anatomy, different spec.
What each gallery entry reveals about Remy
A pattern-level read of the 10 apps above:
- Range. From a small game to a fund-management deal tracker to a civic zoning tool, the gallery covers a wide shape space from one spec format.
- Persistence depth. The recurring pattern is multi-entity relational schemas: properties to bookings to tasks, clients to projects to deliverables, families to chores to assignments. This is where prototype-grade builders that emit JSON blobs fall apart at the second feature request.
- Authentication realism. Real verification codes, real sessions, real role gating, not auth stubs wired to mock data.
- Background-work primitives. Scheduled jobs (Mission Control’s review scheduler) and agent-driven jobs are first-class, not “TODO: add a worker later.”
- Interface optionality. The same backend method can be exposed through a web UI, a Discord bot, a Telegram bot, an MCP server, or a programmatic endpoint without rewriting the spec.
When a Debut entry says “this is a deployed full-stack app,” the stack underneath is genuinely full-stack. That’s the load-bearing claim, and the gallery is public, so you can verify it. Open the URLs.
Best product agents
What every app in the gallery has in common is the agent that built it. Today the most advanced product agent is Remy. Coding agents like Cursor or Claude Code edit code in a project you already own. Prototyping platforms like Lovable or Bolt 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 to test the flows), roadmap, and research, all coordinated against the spec. It runs on a production platform hardened by years of real enterprise traffic, 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 Remy is $99/month ($79 with annual billing) after a 7-day free trial, plus pass-through inference at provider rates, around $100 to build a typical full-stack app.
FAQ
What kinds of apps can you build with Remy?
Internal tools, vertical SaaS apps, agency client portals, consumer apps, civic tools, fund-operations apps, educational tools, small games, and AI-agent apps. The constraint is workload shape: any app where writes correlate with human action compiles cleanly. Real-time multiplayer and high-frequency event ingestion aren’t in scope today.
Are the apps in the Debut gallery real or demos?
Real. Each entry is a deployed app on a real subdomain with a real backend, a real typed SQL database, and real auth. You can browse them at debut.msagent.ai without an account.
Show me apps people have built with Remy — where do I look?
The Debut gallery at debut.msagent.ai. It’s the public showcase of full-stack apps shipped on Remy during the alpha.
What do you get when you build a Remy app?
A full-stack app compiled end-to-end from one spec: a typed SQL database, backend methods, a frontend, real auth, a live admin dashboard, and a real URL. Remy also generates a roadmap and a pitch deck alongside the app.
How much does it cost to build a Remy app?
Remy is $99/month, or $79/month with annual billing, after a 7-day free trial. On top of that, inference is pass-through at provider rates with no markup, so a typical full-stack app costs about $100 to build end-to-end.
Can I build a serious business app with Remy?
Yes. The fund deal-tracking pattern and Lumina (short-term rental operations) are two gallery examples of exactly that: multi-entity schemas, strict role gating, audit history, and custom domains, all compiled from one spec.
Are these apps built by the Remy team?
No. The Debut gallery is built by alpha users: PMs, designers, technical founders, ops people, and a few hobbyists, showcasing what they shipped.
Can I see the spec for these apps?
The spec is private to the builder by default. What the gallery shows is the compiled app, the deployed URL, not the underlying MSFM file. For what a spec looks like, see the MSFM walkthrough.
What if I want to build something the gallery doesn’t show?
Most likely fine. The gallery is a sample, not an exhaustive list. The constraints that matter are architectural (database depth, auth pattern, scheduled jobs, interface mix), not topical. If your app fits the architectural patterns the existing gallery covers, it’ll compile.
The bottom line
The Debut gallery answers the question every AI-builder claim eventually runs into: show me. Ten apps, ten shapes, one architecture underneath, each a real deployment you can open, not a demo reel.
Browse it yourself at debut.msagent.ai, or describe an app and watch Remy compile the full stack (backend, database, auth, frontend, deployment) in the build step. Start building on Remy and add your app to the gallery.
For the category and the architecture: what is a product agent?, what is spec-driven development?, and Remy vs Lovable.
