Use Cases
Who uses Curate-Me, and for what? Here are three scenarios drawn from real deployments.
Cost Governance for AI Teams
The problem
Teams across the company are using AI tools, but nobody has a unified view of the spending. Each team picks its own model, sets up its own API key, and the finance team finds out about the bill at the end of the month. One developer’s autonomous agent ran up $47,000 overnight because there was no budget cap in place.
How it works
Every AI request routes through a single gateway. You change one environment variable — the base URL — and your existing code works exactly as before.
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Team Alpha │ │ Team Beta │ │ Team Gamma │
│ budget: │ │ budget: │ │ budget: │
│ $50/day │ │ $200/day │ │ $20/day │
└──────┬───────┘ └──────┬───────┘ └──────┬───────┘
│ │ │
└─────────┬─────────┘ │
└──────────┬──────────────────┘
▼
┌──────────────────────┐
│ Curate-Me Gateway │
│ │
│ • Per-key budgets │
│ • Model allowlists │
│ • Real-time totals │
│ • Alerts on spike │
│ • Block on overrun │
└──────────┬───────────┘
│
┌──────────┴───────────┐
▼ ▼
┌────────────┐ ┌────────────┐
│ Redis │ │ Dashboard │
│ (live │ │ (cost │
│ counters)│ │ charts) │
└────────────┘ └────────────┘Now every request passes through a governance chain before reaching the provider. You set daily budget caps per team, per project, or per individual key. When spending spikes, you get alerts. When a budget is hit, the gateway blocks further requests instead of letting costs accumulate.
What the platform provides
- Budget hierarchy — org-level, team-level, and per-key daily caps
- Cost anomaly detection — alerts when spending deviates from normal patterns
- Model allowlists — restrict which models each team can access (no GPT-5.1 for the intern’s side project)
- Real-time cost dashboard — see what every team is spending, broken down by model, project, and time period
- Cost attribution tags — label requests by project, feature, or environment for accurate chargebacks
Result
You know what every team spends on AI, in real time. Runaway costs get caught in minutes, not at the end of a billing cycle. Teams stay within budget without needing to change their code.
AI Dev Team Pipeline
The problem
GitHub issues pile up in the backlog because there are not enough developers. Simple tasks — fixing a typo in the docs, adding a missing null check, updating a config file — sit for days alongside the complex work because nobody has bandwidth to pick them up.
How it works
You point the pipeline at a GitHub issue. The system reads the issue, breaks it into subtasks, and spins up isolated containers for each one.
GitHub Issue #142
│
▼
┌──────────────┐
│ Decomposer │ Reads issue, breaks into subtasks
└──────┬───────┘
│
├──────────────────┬──────────────────┐
▼ ▼ ▼
┌────────────┐ ┌────────────┐ ┌────────────┐
│ Container │ │ Container │ │ Container │
│ Subtask 1 │ │ Subtask 2 │ │ Subtask 3 │
│ │ │ │ │ │
│ Code + │ │ Code + │ │ Code + │
│ test + │ │ test + │ │ test + │
│ commit │ │ commit │ │ commit │
└─────┬──────┘ └─────┬──────┘ └─────┬──────┘
│ │ │
└────────┬────────┘ │
└──────────┬───────────────┘
▼
┌─────────────────┐
│ Review Agent │ Automated code review
└────────┬────────┘
▼
┌─────────────────┐
│ Pull Request │ Ready for human review
└─────────────────┘Inside each container, an AI coding agent writes the code, runs the tests, and pushes a commit. When all subtasks are done, the system creates a pull request, runs an automated review pass, and can optionally deploy to staging. A human reviews the PR and merges it.
What the platform provides
- Task decomposition — breaks a GitHub issue into concrete, parallelizable subtasks
- Parallel container execution — each subtask runs in its own isolated environment with full dev tooling
- Automated code review — the output gets a review pass before a human ever sees it
- Deploy pipeline — merged PRs can trigger staging deployment automatically
- Per-task cost tracking — see exactly how much each issue costs to resolve
Result
Simple issues get resolved autonomously. Complex issues get a head start — the AI writes a draft PR that a developer can review and refine in minutes instead of hours. The backlog shrinks. Developers spend their time on the work that actually needs human judgment.
Customer Support Intelligence
The problem
The support team handles thousands of tickets every week. Agents manually triage, research, and respond to each one. There is no systematic way to learn from past resolutions. When AI tools are introduced to help, there are no cost controls — support agents use expensive models for simple lookups, and nobody knows which interactions contain customer PII.
How it works
A fleet of six specialized agents handles the full support lifecycle. Each agent uses the model that fits its job — a fast, cheap model for triage, a capable model for resolution, a reasoning model for escalation decisions.
Customer Ticket
│
▼
┌───────────┐ ┌──────────────┐ ┌──────────────┐
│ Triage │────▸│ Resolver │────▸│ Knowledge │
│ (Haiku) │ │ (Sonnet) │ │ Builder │
│ │ │ │ │ │
│ Classify │ │ Draft reply │ │ Extract │
│ by urgency│ │ from KB │ │ patterns, │
│ and topic │ │ │ │ update KB │
└─────┬─────┘ └──────────────┘ └──────┬───────┘
│ │
▼ ▼
┌───────────┐ ┌──────────────┐ ┌──────────────┐
│ Escalation│ │ Analytics │ │ Quality │
│ (Opus) │ │ (Haiku) │ │ Evolver │
│ + HITL │ │ │ │ (Sonnet) │
│ │ │ Track SLAs, │ │ │
│ Route to │ │ resolution │ │ Identify │
│ human │ │ quality │ │ weak spots, │
│ specialist│ │ │ │ suggest fixes │
└───────────┘ └──────────────┘ └──────────────┘Cost model: Triage and analytics use Haiku ($0.001/ticket). Resolution and quality
use Sonnet ($0.01/ticket). Escalation uses Opus only for complex cases (~$0.05/ticket).
Total fleet cost: roughly $0.02 per average ticket.
What the platform provides
- Multi-agent fleet orchestration — define agent roles, communication patterns, and model assignments from the dashboard
- PII scanning on every ticket — personal data is flagged before it reaches any model
- Human-in-the-loop approval — refunds above a threshold require human sign-off before the agent acts
- Recursive learning — resolved tickets feed back into the knowledge base automatically
- Per-agent cost tracking — see what each agent costs to operate, identify which roles are worth the investment
Result
Tickets get classified in under a second. Resolution quality improves with every interaction because the knowledge base grows continuously. Costs are visible per agent, so you can make informed decisions about which models to use where. Sensitive data never leaves the system without being scanned first.
What these have in common
All three scenarios share the same foundation: route AI traffic through a governed gateway, track every request, and enforce policies automatically. The platform does not require you to rewrite your application or adopt a new SDK. You change a base URL, and governance starts working.
- Get started — set up the gateway in under 10 minutes
- Gateway overview — how the governance chain works
- Platform overview — the full picture