Currently in private beta
The harness already composed for Rails.
Fragua lets a team run, watch, and control many AI agents building Rails apps — with full visibility into the work, the cost, and how the agents behave. It begins with one developer turning an idea into a shipped app, and becomes indispensable when a team is shipping across many products at once.
Everything a control plane promises — plus the two things that matter on your own budget.
Quality, control, and consistency are table stakes — the whole category claims them. What changes the math when agents run on your own keys is knowing what they cost and how they behaved. Fragua is opinionated, Rails-deep, and self-serve: you own the repo and the keys, and we never sit in the middle.
Agents fluent in the Rails 8.1 craft — Hotwire, Solid Queue, Minitest, the One Person Framework — so the code reads like your team wrote it.
Your architect approves the plan in plain language before any agent touches the codebase. Agents don't make unreviewed architectural decisions.
Every workspace runs the same opinionated lifecycle, so two products built months apart still look like one team built them.
Every token rolls up per run, workspace, account, and month. BYOK, billed straight to your provider — you always know what your agents cost, and we can't see your bill.
A durable audit trail of every run: what the agent touched, which model and reasoning effort it used, why it failed, whether it stayed in bounds.
Four phases. One workspace. Zero context loss.
From a one-line product idea to a merged pull request. Each phase produces durable artifacts that become context for everything that follows.
Tell Fragua a one-line idea. It studies similar apps and writes a synthesis you can edit and approve.
From the research, Fragua drafts the MVP plan that defines what to build first. Brand guide and technical guide ship as separate phases.
Define features as structured specs. Each one decomposes into a task list ready for an agent to execute.
Agents implement tasks on a feature branch and open a pull request. Watch the work happen live.
Every artifact persists. Every later phase has access to every earlier one.
Your references, in every agent's context.
Beyond the artifacts each phase produces, every workspace has a Knowledge Base. Upload your own reference material and the spec and execution agents read it as context — design docs, API contracts, house conventions. The agents build against your references, not just the generated plan.
Up to 10 MB per file · 1 GB per workspace · staged into the agent's working directory at run time
The Knowledge Base, the persisted phase artifacts, and the durable run history live in the workspace — not in someone's head. Onboarding, handoffs, and people leaving don't erase the context the agents work from.
Generic agents don't know your codebase. Fragua does.
Fragua's agents ship pre-loaded with the Rails 8.1 vocabulary. Hotwire for the front end. Solid Queue for async work. Rich domain models with concerns. The One Person Framework philosophy from Rails as the default — building like one developer can ship the whole thing.
When the agent reads your code, it knows what a Stimulus controller is. When it writes a test, it writes Minitest with fixtures. When it opens a pull request, it follows the conventions your team already lives by.
- Built-in awareness of maquina_components for views
- Rails MCP Server integration for runtime context
- Per-feature git worktrees for parallel work
- Pull requests opened through your host's own GitHub access
One spine, three axes: the work, the cost, the behavior.
The deepest-built part of Fragua. For a solo dev watching one agent it's a nicety; for a team running many agents across many products, it's the whole job.
Live timelines, durable resumable runs, every turn a row in the event log. Watch the work as the agent produces it.
Token usage rolled up per run, workspace, account, and month — BYOK, billed straight to your provider.
A durable audit trail: run type, model and reasoning effort, failure reasons, watchdog and restart.
Watch the work happen.
The durable events from each agent turn land in the database one row at a time — assistant text, mid-interview questions, terminal artifacts. The browser sees a live timeline as the agent produces it. Token usage and cost are written per turn into their own table. Cancel signals the runner and takes effect within five seconds.
Turbo Streams broadcasts each turn as the agent produces it. The browser never asks; the server pushes.
The database keeps what matters — assistant text, questions, terminal artifacts, per-turn cost. Tool calls and intermediate state stay in the runner stream.
Close the browser. Come back tomorrow. The run is still going. The event log is still complete.
You bring your AI key. We bring the receipts.
Fragua never proxies your AI calls. Every token your agents consume is billed directly to the provider your key belongs to. We can't see your billing or charge you for usage.
What we do is parse the usage events from every run and roll them up — per AgentRun, per Workspace, per Account, per month. Finance knows where every dollar went.
At launch Fragua runs on Anthropic Claude via Claude Code. Other AI services and platforms plug in as they ship.
Rails 8.1. SQLite. Solid Queue. Hotwire.
Fragua is built on the Maquina stack — vanilla Rails with the One Person Framework philosophy. The same conventions you'd want in a project Fragua builds for you.
The framework, modern and complete.
Five embedded databases, one server.
Database-backed async jobs.
Turbo + Stimulus, server-driven UI.
Passwordless sign-in via email codes.
Pushes and PRs through your host's access.
How we deploy Fragua to our infrastructure.
Continuous backup with ~1s RPO.
Flat per-account. BYOK. No surprises.
You pay Fragua a flat monthly fee for the platform. You pay your AI provider for tokens. We never sit between the two.
For independent Rails developers and personal projects.
- 1 user · unlimited workspaces
- BYOK — your AI spend, billed to you
- Full cost dashboard
- Per-feature git worktrees
For small consultancies and product teams.
- Up to 10 users · unlimited workspaces
- BYOK — your AI spend, billed to you
- Admin & member roles, shared workspaces
- Audit trail across every agent run
- Priority access to new features
Currently free during private beta · Pricing begins 30 days after public launch with email notice
Tell us what you're building.
Fragua is in private beta with a small group of teams and solo builders. We're not opening seats on a schedule — join the waitlist and we'll reach out when there's room for the work you're describing.