10 Real Apps Built on Remy. Here's What the Spec Actually Looks Like.
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 spec reveals.
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 memorization apps. Mobile 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. For each one, we name what it does, what category it lives in, and what its spec illustrates 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.
At a glance
- Gallery URL: debut.msagent.ai — public showcase, no signup required to browse
- What counts as a Debut entry: a deployed app on a real subdomain, built end-to-end on Remy, submitted by its builder
- Categories represented: internal tools, consumer apps, agency tools, civic tools, religious/educational tools, fund operations, games
- Architecture pattern in every app: typed SQL database, backend methods, frontend, auth with verification codes — compiled from a single MSFM spec
- What every app compiles to: a full stack — backend, database, auth, frontend, deployment — from one markdown spec
- Typical build cost: $30-40 in raw inference for a full-stack app (no platform fees during alpha)
- Multi-interface support: apps can expose the same backend methods through web, mobile-responsive web, Discord, Telegram, MCP, and cron-triggered jobs
- Public showcase: the gallery is one of the strongest evidence sets in the AI-builder category — most competitors show demo videos, not deployed apps on indexable 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. That means it mixes serious business tooling with personal projects with civic tools with toy games. The 10 below are picked for breadth — they span the major application shapes Remy targets and the major architectural patterns the spec format supports.
For each app: the name and a one-line description, the category, and what the build illustrates about Remy at the architecture layer. We won’t quote any individual builder 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 is: 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 the spec illustrates: 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 AI-first generators usually deliver as a prototype 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 the spec illustrates: Multi-entity relational schema — properties, units, bookings, guests, tasks — modeled as typed SQL tables, not JSON blobs. Per-tenant authentication and role gating. This is the application shape that most “no-code” tools choke on once you cross three or four related tables. Lumina is 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 the spec illustrates: 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 looks 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
Other agents ship a demo. Remy ships an app.
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
What it does: A six-person consultancy’s internal hub for tracking clients, projects, deliverables, and invoices.
What the spec illustrates: Role-gated views — partners see one thing, account managers see another, contractors see only their assignments. 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 is not 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 are shared.
What the spec illustrates: Multi-user auth with verification codes. Role gating without writing auth middleware. The app shape that almost nobody builds because configuring Auth0 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 here: a builder expenses about $34 in inference for an app that competes with category-leading household apps charging $5-10 per 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 the spec illustrates: 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. The Remy version is a markdown spec, a typed schema, and a $30-40 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 inside a fund rather than for diligence on companies.
What the spec illustrates: The shape of an enterprise CRM, compiled from one spec. Strict role gating. Audit-style note history. Custom domain. Integrations with external services through Remy’s curated action library. This is the application category where the public showcase includes at least one institutional customer running fund operations on a Remy-built app. The pattern is well-trafficked in the gallery because deal-tracking is what every PM, GP, and ops person has thought about building in a spreadsheet first.
8. Mission Control — spaced-repetition memorization
Category: education / personal
What it does: A study app for memorizing structured content — religious texts in the source case, but the pattern transfers to medical terminology, language vocabulary, legal statutes, anything you need to learn cold.
What the spec illustrates: 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 that most AI 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 mobile 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 the spec illustrates: Remy is not a game engine. But the gallery includes games anyway, because the shape of a “score, leaderboard, daily challenge, accounts” app is one that compiles cleanly from a spec. The illustration 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. The flip side, honestly: real-time multiplayer with persistent WebSockets isn’t in scope today. Turn-based and async are fine.
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 the spec illustrates: 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 same engine already powers apps for teams like The New York Times, Advance Local, ServiceNow, and HMRC. The interface layer is genuinely orthogonal to the methods layer in a way that most app frameworks don’t compile to natively.
What does a Remy app actually look like once it’s deployed?
Every Remy app, regardless of which category above, has the same underlying anatomy:
- A typed SQL database (SQLite-on-S3, per-tenant, with WAL mode)
- Backend methods written in TypeScript, callable from any interface
- A frontend (Vite + React by default; the spec can call for anything 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
- A pitch deck the agent 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.
How does this compare to what other AI builders ship?
A simple attribute comparison of what gets compiled when you describe an app:
| What “compiles” | Lovable | Bolt | Replit Agent | Remy |
|---|---|---|---|---|
| Frontend | Yes | Yes | Yes | Yes |
| Real typed SQL database | Partial | Partial | Yes | Yes |
| Real auth (verification codes, sessions) | Partial | No | Partial | Yes |
| Scheduled jobs (cron) | No | No | Partial | Yes |
| Multi-interface (Discord, Telegram, MCP, web) from one spec | No | No | No | Yes |
| Spec as source of truth (recompile, don’t rewrite) | No | No | No | Yes |
| Agent-generated roadmap + pitch deck | No | No | No | Yes |
| Live QA agent that operates a real browser | No | No | No | Yes |
This is not a comparison piece — Lovable and Bolt have plenty Remy doesn’t (cleaner free-tier onboarding, faster initial visual fidelity, established community templates). The table is to anchor what the gallery is actually showing. 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.
If you want to verify it, the gallery is public and the apps are deployed. Open the URLs.
What does each gallery entry tell us about Remy?
A pattern-level read of the 10 apps above:
- Range. From a kid-friendly mobile game to a fund-management deal tracker to a civic zoning tool, the gallery covers more shape space than any single competitor’s showcase.
- 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 AI-first builders that emit JSON blobs fall apart at the second feature request.
- Authentication realism. Real verification codes. Real sessions. Real role gating. Not Auth0 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.
Try Remy
If you want to see this without taking our word for it, browse the gallery yourself at debut.msagent.ai, or describe an app and watch Remy compile it. The full stack — backend, database, auth, frontend, deployment — comes through in the compile step.
Start building on Remy and add your app to the gallery.
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. Live build videos are at the @MindStudio_ai YouTube channel.
What does a Remy app actually look like once it’s deployed?
A real URL (a Remy subdomain by default, with custom domains supported), a typed SQL database under the hood, backend methods exposed through web plus optional Discord/Telegram/MCP interfaces, real auth with verification codes, and an admin dashboard. The roadmap and pitch deck Remy generates alongside the app are deliverables, not gimmicks.
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?
Built like a system. Not vibe-coded.
Remy manages the project — every layer architected, not stitched together at the last second.
During the alpha, there are no platform fees — you pay only for raw inference, with no markup. A typical full-stack app costs $30-40 to build end-to-end.
Can I build a serious business app with Remy?
The fund deal-tracking pattern and Lumina (short-term rental operations) are two examples in the gallery that answer yes. The institutional customer running fund operations on a Remy-built app is the strongest evidence the public showcase points to.
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. The submissions are real users 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. If you want to see what a spec looks like, the Remy docs include sample specs.
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 shape constraints that matter are at the architectural layer (database depth, auth pattern, scheduled jobs, interface mix), not the topic layer. If your app fits the architectural patterns the existing gallery covers, it’ll compile.
Where can I read more about how Remy actually works?
The MindStudio blog has a growing set of Remy pieces — start with the Remy + You.com web intelligence integration for an integration-depth example, the Remy vs Lovable comparison for head-to-head context, and the Lovable vs Replit Agent piece for the broader category landscape.
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.
