Skip to content
PTSee how it works

Pitch the idea. Librator
builds it to spec, to scale.

Spec-driven development, end to end: it writes the spec, picks a model per task,
has another model review the work, and tells you the cost before any code runs.

What do you want to build?

A SaaS for clinics to book appointments, with Pix payments, WhatsApp reminders and multiple locations per customer.

ExampleSee the plan for this idea
Installer coming soon

Works with the agents you already pay for

Why Librator

Between a prototype
and an orchestrator.

Prototype tools stop at the demo. Orchestrators need the tasks and the agents picked before they start. Librator does the part in between, and carries it to the end.

    • Scale
    • Tenancy
    • Auth
    • Billing

    Plans for scale

    An interview comes first, asking what changes the architecture: scale, tenancy, auth, billing, sensitive data. The scope is written for real users, not a demo.

    • T01Claude Fable 5.1
    • T06Grok 4.6
    • T07Luna Max
    • T10Astra (OpenAI)

    The right model per task

    Each task goes to the model that fits it, from any provider: a fast one like Luna Max for small UI tweaks, a frontier one like Astra or Claude Fable for architecture and security.

  • T04 · Claude Sonnet 5.5, reviewed by Astra (OpenAI)

    highSession tokens never expire.

    A second opinion

    On sensitive tasks, a model from another provider reads the diff before the commit, and sends it back when it finds something.

  • $16.33

    API-equivalent · example

    Cost before code

    Every task has a cost range, summed by provider and checked against the subscriptions you already pay for.

BMAD and Spec Kit run spec-driven development as documents you drive prompt by prompt. Librator turns the same idea into a product.

How it works

Describe it once.
Librator takes it to the end.

You write the idea in plain words. Librator asks what changes the architecture, writes the spec, plans the tasks and picks the agents.

BriefingScopePlan

Clinic Scheduler

Two questions at a time, starting with what changes the project.

A SaaS for clinics to book appointments, with Pix payments, WhatsApp reminders and several locations per customer.

Librator

Got it. Before we get to scheduling, two questions that change the architecture:

  1. Each clinic only sees its own data, right? I'll assume multi-tenant with isolation per clinic.
  2. How many clinics do you expect in the first year?
Your answer

Answer, paste a reference, or type / for shortcuts

Send

Clinic Scheduler

Online booking for clinics with several locations, Pix payments and WhatsApp reminders.

Summary

Small and mid-sized clinics publish open slots per practitioner and location. Patients book without an account, pay a deposit by Pix and get reminders. Staff manage the schedule, confirm attendance and see the day's takings.

Features

  • Schedule per practitioner and locationmust haveSlots, blocked times and squeeze-ins, with day and week views.
  • Patient self-bookingmust haveA public link per clinic, no account needed, confirmed over WhatsApp.
  • Pix depositmust haveCharge a deposit at booking, marked as paid automatically by the PSP webhook.
  • WhatsApp remindersshould haveA reminder 24 h before, with attendance confirmation.
  • No-show reportnice to haveNo-show rate per practitioner and per location.

Technical requirements

Expected users
200 clinics in year 1, about 600 locations
Tenancy
multi-tenant
Auth
magic link for staff; patients need no account
Billing
monthly subscription per location
Data sensitivity
personal data
Compliance
LGPD

Risks

  • If the PSP webhook is down, bookings never get marked as paid.high riskDaily reconciliation through the PSP API.
  • WhatsApp's per-message cost grows with the number of locations.medium riskOne reminder, with confirmation in the same conversation.
5 features · 2 risks
View plan (10 tasks)

Clinic Scheduler

Execution plan: 10 tasks in 6 phases. Costs come from the core estimator.

Phase 1
T01Modular monolith architecture~$2.71
claude-fable-5-1· claude-code (claude max 5x)· review astraarchitecture · M

Monorepo layout, modules per domain, multi-tenant isolation conventions, queues for reminders and webhooks, logging and Sentry.

Architecture needs a frontier model; covered by your claude max 5x subscription; reviewed by another provider (OpenAI) for a second opinion.

Phase 2
T02Data model and initial migrations~$0.53
claude-opus-5-5· claude-code (claude max 5x)data model · M

Tenants, locations, users and roles, practitioners, patients, appointments, payments, subscriptions and LGPD consent.

Data model needs a strong model; covered by your claude max 5x subscription.

T03CI and deploy on Fly.io~$0.01
gemini-3-flash· gemini-cli (api)infra · M

Lint, typecheck, tests and build. Continuous deploy with managed Postgres, secrets and health checks.

Infra needs a fast model; billed to your Google API key.

Phase 3
T04Magic link auth and roles~$1.40
claude-sonnet-5-5· claude-code (claude max 5x)· review astraauth · M

Staff sign-in by email, roles per location, sessions that expire.

Auth needs a strong model; covered by your claude max 5x subscription; reviewed by another provider (OpenAI) for a second opinion.

T05Schedule per practitioner and location~$3.15
kimi-k3· kimi-cli (api)backend · L

Slots, blocked times, squeeze-ins and conflicts, with an API for the day and week schedule.

Backend needs a strong model; billed to your Moonshot AI API key.

Phase 4
T06Front desk schedule screen~$3.45
grok-4-6· grok-build (api)frontend · L

Day and week views, drag to reschedule, attendance confirmation.

Frontend needs a strong model; billed to your xAI API key.

T07Public booking link~$0.03
luna-max· codex (chatgpt plus)frontend · M

A page per clinic to pick location, practitioner and time, with no account.

Frontend needs a fast model; covered by your chatgpt plus subscription.

T09WhatsApp reminders~$0.58
kimi-k3· kimi-cli (api)integration · M

A reminder 24 h before, with attendance confirmation in the same conversation.

Integration needs a strong model; billed to your Moonshot AI API key.

Phase 5
T08Pix deposit~$0.81
claude-sonnet-5-5· claude-code (claude max 5x)· review grok-4-6billing · M

Charge at booking, PSP webhook and daily reconciliation.

Billing needs a strong model; covered by your claude max 5x subscription; reviewed by another provider (xAI) for a second opinion.

Phase 6
T10Security and LGPD audit~$3.66
astra· codex (api)· review claude-fable-5-1security · M

Tenant isolation, consent, data retention and data export.

Security needs a frontier model; billed to your OpenAI API key; reviewed by another provider (Anthropic) for a second opinion.

Actual planning cost so far: $0.73Export to the repository

Clinic Scheduler

Development: 1 of 10 tasks merged.

Run all
Phase 1
T01Modular monolith architecturemergedClaude Code · claude-fable-5-1
Phase 2
T02Data model and initial migrationsawaiting mergeClaude Code · claude-opus-5-5ready on branch librator/T02-data-model-and-initial-migra; merge it to unblock the tasks that depend on it
T03CI and deploy on Fly.ioreadyGemini CLI · gemini-3-flash
Phase 3
T04Magic link auth and rolesblockedClaude Code · claude-sonnet-5-5depends on T02
T05Schedule per practitioner and locationblockedKimi Code · kimi-k3depends on T02
Phase 4
T06Front desk schedule screenblockedGrok Build · grok-4-6depends on T05
T07Public booking linkblockedCodex · luna-maxdepends on T05
T09WhatsApp remindersblockedKimi Code · kimi-k3depends on T05
Phase 5
T08Pix depositblockedClaude Code · claude-sonnet-5-5depends on T07
Phase 6
T10Security and LGPD auditblockedCodex · astradepends on T04, T08
1 of 10 merged · 1 awaiting merge

Clinic Scheduler

Review from Nov 2, 1:24 AM.

Not yet

The schedule and the public link work end to end, but the Pix deposit doesn't match the webhook to the appointment, and WhatsApp reminders don't exist yet. It can ship once Pix is fixed.

5 of 39 acceptance criteria checked·1 of 10 tasks complete·audit $0.84 API equivalent

Spec features

Schedule per practitioner and locationdone
Public booking linkdone
Pix depositpartial
WhatsApp remindersmissing
LGPD consentpartial
Librator in sample mode, with the Clinic Scheduler example.

A real plan

Ten tasks, each with
its model, review and cost.

The example plan for the clinic scheduling app: each task on the model that fits it, with the cost from Librator’s estimator.

  1. T01Modular monolith architecture

    Monorepo layout, modules per domain, multi-tenant isolation conventions, queues for reminders and webhooks, logging and Sentry.

    frontier tierClaude Fable 5.1reviewed by Astra (OpenAI)
    ~$2.71

  2. T02Data model and initial migrations

    Tenants, locations, users and roles, practitioners, patients, appointments, payments, subscriptions and LGPD consent.

    strong tierClaude Opus 5.5
    ~$0.53

  3. T03CI and deploy on Fly.io

    Lint, typecheck, tests and build. Continuous deploy with managed Postgres, secrets and health checks.

    fast tierGemini 3 Flash
    ~$0.01

  4. T04Magic link auth and roles

    Staff sign-in by email, roles per location, sessions that expire.

    strong tierClaude Sonnet 5.5reviewed by Astra (OpenAI)
    ~$1.40

  5. T05Schedule per practitioner and location

    Slots, blocked times, squeeze-ins and conflicts, with an API for the day and week schedule.

    strong tierKimi K3
    ~$3.15

  6. T06Front desk schedule screen

    Day and week views, drag to reschedule, attendance confirmation.

    strong tierGrok 4.6
    ~$3.45

  7. T07Public booking link

    A page per clinic to pick location, practitioner and time, with no account.

    fast tierLuna Max
    ~$0.03

  8. T08Pix deposit

    Charge at booking, PSP webhook and daily reconciliation.

    strong tierClaude Sonnet 5.5reviewed by Grok 4.6
    ~$0.81

  9. T09WhatsApp reminders

    A reminder 24 h before, with attendance confirmation in the same conversation.

    strong tierKimi K3
    ~$0.58

  10. T10Security and LGPD audit

    Tenant isolation, consent, data retention and data export.

    frontier tierAstra (OpenAI)reviewed by Claude Fable 5.1
    ~$3.66

Cost

Predictable cost.
No surprises.

Before any code runs, the plan adds up every task by provider and checks it against what you already pay for.

  • Your subscriptions

    Claude Max 5x + ChatGPT Plus

    ~$8.88/mo

    of usage, absorbed by the plans you already have. 5 of 10 tasks run on them.

    • Anthropic ~$4.29/mouse what you have
    • OpenAI ~$4.59/mouse what you have

  • The whole plan

    API-equivalent cost

    $16.33

    between $9.80 and $29.38, for the whole build.

    • 10 tasks in 6 phases
    • 4 reviewed by another provider
    • Paid per token: $12.01

  • Per token

    Google + Moonshot AI + xAI API

    ~$7.45/mo

    on your own keys, for the tasks that fit those models best. Too little for a fixed plan.

    • Google ~$0.01/mobuy API credits
    • Moonshot AI ~$3.73/mobuy API credits
    • xAI ~$3.71/mobuy API credits

Example: the clinic scheduling app, for someone with Claude Max 5x, ChatGPT Plus and API keys for OpenAI, Google, Moonshot AI and xAI. Models picked per task for this example; costs computed by Librator’s estimator; some prices are unverified and use the tier average.

After the plan

From plan to merged code.
Without picking every agent.

agenda-clinica/ 7 files written

SPEC.md, TASKS.md and the ADRs are the format spec-driven workflows already read, so the plan fits the flow you already use, with or without the app. If you’ve used BMAD or Spec Kit, the documents will feel familiar; the difference is that Librator writes them for you, from the interview.

  • SPEC.mdfeatures, requirements, reference architecture
  • TASKS.mdthe task graph, with dependencies and acceptance criteria
  • BUDGET.mdcost by task and by provider
  • AGENTS.mdinstructions any coding agent reads
  • CLAUDE.mdthe same, for Claude Code
  • docs/adr/the architecture decisions, one file each
  • .librator/plan.jsonthe plan the command line runs

Each task runs on the agent the plan chose, in its own git worktree: tests, a review by another model, a commit to the task’s branch. The queue walks the graph two at a time; merges are previewed, and conflicts stay with you.

T01queuedfable-5-1T02queuedopus-5-5T03queuedgemini-3-flashT04queuedsonnet-5-5T05queuedkimi-k3T06queuedgrok-4-6T07queuedluna-maxT08queuedsonnet-5-5T09queuedkimi-k3T10queuedastra

0 of 10 in base

Built and tested with simulated agents; it hasn’t run a real project yet.

After each task, Librator reads the agent’s local logs: the API-equivalent cost, split into what your subscription covered and what would be billed per token. Your runs calibrate the next estimate.

TaskModelEstimatedFrom the logsPaid by
T01Claude Fable 5.1~$2.71$3.04covered by Claude Max 5x
T02Claude Opus 5.5~$0.53$0.59covered by Claude Max 5x
T03Gemini 3 Flash~$0.01$0.01billed per token
T04Claude Sonnet 5.5~$1.40$1.57covered by Claude Max 5x
T05Kimi K3~$3.15$3.53billed per token
T06Grok 4.6~$3.45$3.86billed per token
T07Luna Max~$0.03$0.03covered by ChatGPT Plus
T08Claude Sonnet 5.5~$0.81$0.91covered by Claude Max 5x
T09Kimi K3~$0.58$0.65billed per token
T10Astra (OpenAI)~$3.66$4.10billed per token
Total, sample run~$16.33$18.29

Sample run with simulated agents; Librator hasn’t measured a real project yet.

FAQ

Questions
answered.

How is Librator different from Lovable or an agent orchestrator?

Prototype tools generate an app from a prompt and decide the architecture for you. Orchestrators run agents once you already have tasks and picked an agent for each. Librator starts at the idea with an interview that asks what changes the architecture, plans for real users, picks the model per task and carries the plan to the end.

How does it compare to BMAD or Spec Kit?

They’re third-party projects that run spec-driven development as a process in documents, driven prompt by prompt. Librator turns that process into a product: a guided interview, a task graph with dependencies, models and budget computed for you, and runs that are measured. Librator isn’t built on either of them and doesn’t integrate with them.

Do I need another AI subscription?

No. Librator uses the logins and subscriptions you already have, through each agent’s own CLI, or an API key you provide. The plan tells you whether what you pay for covers the work, or what to buy.

Does my code leave my machine?

No. Projects, plans and runs stay on your machine. Telemetry is off by default; if you turn it on, it sends anonymous numbers per task (type, model, tokens, cost, outcome) and never names, specs, prompts, code or paths.

Which agents does it run?

Claude Code, Codex, Kimi Code and Gemini CLI. Cursor, OpenCode and Grok Build can be assigned in the plan; you run those tasks yourself.

How accurate is the cost estimate?

It’s a range, in API-equivalent dollars. Cost profiles start as documented assumptions and calibrate with your own runs, and the real cost is read from the agents’ logs after each task.

Can I use it today?

All five steps are in the app, from briefing to review. Development and review are tested with simulated agents and haven’t run a real project yet. The installer is coming soon.

Agents

Runs on your agents.
With your logins.

Each agent runs through its own login, or an API key you provide. Some are only assigned in the plan, and you run those tasks yourself.

Agents Librator runs: Claude Code, Codex, Gemini CLI, Kimi. Agents you can assign in the plan and run yourself: Grok, Cursor, OpenCode.

Top row: Librator runs them. Bottom row: assigned in the plan, run by you.

Built for apps that need to scale.

The installer is coming soon. Librator runs on your machine, with the agents you already pay for.

See the example plan