Frequently asked questions.

What is Remy?

Employees are building custom business tools with AI coding agents. Remy is how your organization owns and manages all of it: a managed infrastructure platform for employee-built applications.

Chances are, your non-technical employees (sales, ops, finance, and so on) are already building custom business tools using Claude Code, Cursor, Codex, and other AI coding agents. That's often a good thing: the people building these tools know exactly what's missing.

The problem: none of those applications are owned, visible, or controlled by the organization. No IT oversight. No cost controls. No governance. If the person who built something leaves, the org is left with nothing.

Remy fixes that. Organizations adopt Remy, provision their employees on it, and configure their coding agents to build on Remy's infrastructure. Every application employees build (database, auth, hosting, integrations) lives on the org's Remy instance. IT sees everything, controls everything, and the organization owns everything.

More on what this looks like inside an organization.

What problem does Remy solve?

Non-developer employees are building software. Finance leads are building approval tools. HR teams are building onboarding portals. Operations managers are building inventory systems. They're doing it with AI coding agents because the barrier to building real software is effectively gone.

The problem is where they're building it: personal accounts, personal GitHub repos, whatever free tier they signed up for on a Tuesday afternoon. The organization has no visibility into what's being built, who has access to what data, which AI models are being called, what those models cost, or whether PII is leaking through an app nobody in IT has ever heard of. When the employee leaves, the application, and everything it knew, leaves with them.

This isn't a future risk. It's already happening inside every mid-market and enterprise organization, whether IT has noticed yet or not.

What's at risk without it?

Without Remy, none of this is owned, tracked, or governed:

• Visibility: no central view of what applications exist or what they do
• Data governance: no control over which data employees' apps can access
• Model oversight: no visibility into which AI models are being called or at what cost
• Cost control: no spend caps, no budget attribution, no ROI tracking
• PII protection: no detection of sensitive data flowing through ungoverned apps
• Continuity: apps disappear when the employee who built them leaves

Together, it adds up to an organization that has no idea how much of its own operating logic now lives in tools nobody signed off on.

Why now?

Because the tools are getting better. Twelve months ago, building a real internal application required engineering resources. Today, a finance director can ship a functioning approval workflow in an afternoon using Claude Code. The volume of employee-built applications inside every org is compounding, and without a managed infrastructure layer underneath, the governance problem compounds at the same rate.

The trend isn't slowing down. The moment to put infrastructure under it is now, not after the shadow IT sprawl is already unmanageable.

How should IT, legal, and procurement think about this?

Different stakeholders land on Remy from different angles. The platform is built to satisfy all of them at once:

• Executives care about the business case: employees are already building tools that solve real operational problems for free; Remy is the difference between capturing that value permanently and losing it the day someone quits.
• IT cares about ownership and control: who has access to what, which models are approved, what it's costing, and whether it's auditable.
• Legal and procurement care about compliance posture: SOC 2 certification, GDPR compliance, and a governance dashboard that gives them something to actually point to during a vendor review or audit, rather than a shrug.

How does an organization adopt Remy?

IT or operations provisions the organization on Remy and sets the rules: which employees have access, which AI models they can use, which data sources they can connect to, and what the spend limits are.

Employees then keep using whatever coding agent they already prefer (Claude Code, Cursor, Codex), configured to build on Remy's infrastructure. Every application they build lands on the org's Remy instance automatically, under the rules IT set.

Do employees have to change tools?

No. Remy is agent-agnostic. Employees keep using Claude Code, Cursor, Codex, or whichever tool they already prefer. Remy is the infrastructure underneath: the database, auth, hosting, integrations, and governance layer. The org just configures its coding agents to build against Remy’s platform.

From the employee’s side, nothing changes. From IT’s side, everything is now visible and governed.

What is the spec, and why does it matter?

Remy maintains a structured, human-readable spec file as the source of truth alongside every application’s code. The spec describes what the app does, who it’s for, and how it handles data. Code is generated, and regenerated, from the spec, not the other way around.

That’s what makes governance practical. Instead of asking IT to audit thousands of lines of TypeScript, a department head can read a plain-language spec describing what an employee is building before it ships. That’s also what makes compliance possible at scale.

And the spec outlives the person who wrote it. When the original builder moves on, it tells the next person what the application is supposed to do, not just what the code happens to do.

The whitepaper on spec-first development goes into this properly.

What infrastructure does Remy provide?

Every application built on Remy gets the full managed stack automatically:

• Managed database, authentication, and SSO via the org's identity provider
• Hosting, CDN, and custom domains
• Isolated file storage, with uploads served from a separate domain to prevent same-origin attacks
• On-demand image resizing and video transcoding
• Transactional email with SPF, DKIM, and DMARC configured, and sender reputation managed automatically
• Analytics, frontend error reporting, and application performance monitoring
• Rate limiting and abuse protection at the infrastructure level
• 1,000+ pre-authenticated third-party integrations (CRMs, Slack, accounting platforms, data warehouses)
• 200+ AI model providers, inference billed at provider rates
• SOC 2 Type 1 and Type 2 certified, GDPR compliant

None of this requires configuration from the employee building the application. It's simply the platform any Remy application compiles against, the same way you don't configure TCP/IP before deploying a website.

The Platform has the full list, with detail on each piece.

Can Remy connect to our existing systems?

Yes. Remy connects to the systems you already run (CRMs, Slack, accounting platforms, data warehouses) through more than 1,000 pre-authenticated connectors, and organizations federate in over SAML or OIDC from Okta, Entra ID, or Google Workspace. The org controls which applications and which employees can reach which systems, and that access control lives at the org level, not the individual app, so IT sets the boundary once instead of re-litigating it every time someone builds something new.

One distinction matters here: an app's database holds its own working state, not your system of record. Your Snowflake, SAP, or Salesforce doesn't move. The app pulls reference data in, pushes results back, on a schedule or live if the workload needs it.

Does the organization own the code?

Yes. Remy generates full-stack, modern TypeScript that the organization owns outright. It's not locked into a proprietary format, and it's not trapped inside the Remy system. Any engineering team can read it, maintain it, and move it elsewhere.

What happens to our apps if Remy goes away?

They're portable. Remy generates standard TypeScript, not a proprietary format and not a runtime that only executes here. An organization that wanted to leave could take the repository, the spec, and its data, and run them elsewhere.

What AI models does Remy support?

200+ AI model providers, including Anthropic, OpenAI, and Google. IT configures which models employees are permitted to use within the org's Remy account. Inference cost passes through at provider rates with no markup. Bring-your-own-model is supported for organizations with specific procurement or compliance requirements.

More on models and agents.

What certifications does Remy hold?

SOC 2 Type 1 and Type 2. GDPR compliant. Current reports and the full security posture are published on the Trust Center.

How does Remy handle PII and sensitive data?

Remy includes PII detection at the infrastructure level. The governance dashboard gives IT and compliance teams real-time visibility into what data is being accessed, by which applications, using which models. Every model call and external API call is logged.

This visibility applies to applications built on the org's Remy instance. Remy doesn't detect or monitor applications employees build on personal accounts or other tools outside Remy.

The audit log covers what gets recorded and who can see it.

Where is our data stored?

An administrator pins the workspace to a region, and everything Remy stores at rest for that workspace is written there. Four regions today, and the list grows: the United States, the European Union (Frankfurt), Canada, and Australia (Sydney).

The choice is changeable at any time. Switching regions triggers an opt-in migration that relocates data already stored.

The region map shows where each one sits.

What's the uptime commitment?

There's no public uptime number to quote: SLA terms are set per contract during procurement, not published in advance. Talk to us for specifics.

Remy runs on AWS and Cloudflare, with per-release database isolation, atomic deploys, durable storage, and monitoring across the fleet. Live availability and incident history are published on the Trust Center.

What if the person who built an app leaves?

Because the application lives on the organization's Remy instance, not on an employee's personal account or personal GitHub repo, the org retains full ownership and access. The spec, the code, the infrastructure, and the documentation all persist. Another team member, or a new hire, picks up exactly where the previous person left off, with the spec as the map.

Do you support on-premise deployment?

Yes. For customers whose procurement requires it, Remy supports on-premise deployment.

What controls do IT and operations get?

• User provisioning and de-provisioning via the org's identity provider (SSO)
• Granular permissions on models, data sources, and environments, per employee
• Real-time oversight dashboard showing every application on the org's account
• Model call logging and cost tracking, per application and per user
• PII detection across application data
• Spend caps and cost controls
• ROI analytics by application and team
• Audit trail that updates as applications evolve

Does this work without a large IT team?

Yes. The controls are meant to be run by an operations or enablement lead, not a dedicated platform engineering team. Provisioning, permissions, and the oversight dashboard are built for whoever owns access decisions in the org, which in a mid-market company might be a Director of IT working alone.

What kinds of applications do employees build?

Remy is infrastructure, not a fixed set of templates, so it fits almost any full-stack application. Common examples:

• Custom inventory and asset tracking for operations teams
• Approval and review workflows for finance teams
• Employee onboarding and HR portals
• Sales operations extensions and lightweight CRMs
• Vendor and contract management systems
• Data dashboards and reporting tools
• Fund management and operations tooling

Does Remy support native mobile apps?

Remy builds responsive web apps that work well in mobile browsers. It doesn't produce native iOS or Android apps for the app stores.

Will Remy become obsolete as AI models improve?

Frontier models will keep getting better at writing code. That's good for you, not a threat.

The hard part of building real software inside a company was never generating the code. It's everything around it: governance, ownership, auditability, integration with the systems you already run, keeping it maintained as things change. Better models make the code-generation step cheaper and better. That makes the rest of the platform, the part that turns what an employee builds into something the company can actually own and govern, more valuable, not less.

What does Remy cost?

For an individual, $99 a month, or $79 a month billed annually, with a seven-day free trial. That covers Remy and everything it runs on: the agent and its specialist sub-agents, hosting, databases, authentication, deployments, and monitoring.

AI model usage is separate, billed at whatever the provider charges, with nothing added on top. Organizations are priced per seat, set during procurement.

Full plan details are on the pricing page.

How is model usage billed?

Model usage is billed at whatever the provider charges, across Anthropic, OpenAI, and the rest of the 200+ supported providers. No markup.

Two ways to pay: fund a balance and let Remy pay providers on your behalf, or connect your own API keys and get billed directly. Organizations running their own models, on private cloud or on-premise, can do that instead.

What is Remy Agent?

Remy Agent is Remy's own coding agent, for organizations that want the build process itself inside the governed workflow. It runs the full build cycle: spec, design, code, QA, and deployment. Then it stays on for the post-launch loop.

Who's on the agent team inside Remy Agent?

Remy Agent coordinates six specialist sub-agents:

• Coding Agent: frontier coding models informed by production codebases
• Design Agent: trained on a curated design reference library, producing genuinely custom visual designs rather than generic templates
• Roadmap Agent: owns the product roadmap as a persistent artifact; one click adds the next feature
• QA Agent: interacts with a real browser, clicks through flows the way a user would, and writes structured bug reports and video walkthroughs
• Architecture Agent: provides staff-level architectural review on every meaningful structural decision
• Research Agent: gathers references, studies competitors, and pulls in platform-specific context

What does Remy Agent do after the build?

The same agent team handles the post-launch loop:

• Marketing assets: social, email, press kits, ad creative
• Production monitoring: watches logs, error rates, and latency, and prepares PRs when something breaks
• Bug fixes: traces crashes and patches the code
• Documentation: auto-generated and kept current
• Compliance and audit trails: maintained as the product evolves
• Roadmap iteration: the next feature is one click from the maintained roadmap

What is the auto-roadmap?

The Roadmap Agent doesn't just track a list you type in. It automatically generates a multi-lane roadmap of pre-written specs for the application, so the next feature is already scoped and ready to build with one button press.

How do I bring Remy to my organization?

If you handle IT, operational enablement, cost control, or governance, get in touch or email enterprise@goremy.ai. That's also where enterprise pricing, procurement, and demo requests go.

If you're an individual who wants to start building with Remy Agent, sign up and get going directly.

How long does a build take?

A typical internal tool takes 30 minutes to a few hours, from first description to a deployed application. More complex applications with multiple modules may take several sessions.