The $50K Question: Which Agent Is Eating Your AI Budget?

You’re running five agents on GPT-4o: a chat assistant, a document summarizer, a search reranker, a checkout copilot, and an onboarding flow. Your monthly bill is $50,000. Your CFO asks: “How much of that is the chat agent versus the summarizer?”

You have no idea. Nobody does.

AI API calls are opaque by default. You get one invoice from OpenAI. One line item. No breakdown by agent, product, team, or environment. And most routing and observability layers you bolt on top don’t split this out natively either — the cost ends up aggregated into a single dashboard number that nobody can act on.

How Most Tools Handle This (Spoiler: They Don’t)

We looked at five popular AI tooling layers — routers, observability platforms, and proxy stacks — to see how they approach per-agent cost attribution:

Portkey

Portkey tracks cost and supports virtual keys per team, but cost attribution is at the key level, not the agent or feature level. If multiple agents share a key, you can’t split the spend. You’d need to create and manage a separate virtual key per agent — doable, but operationally heavy once you pass three or four agents.

Helicone

Helicone has excellent logging and lets you tag requests with custom properties. You could add an agent property to every request and then filter by it in the dashboard. But this is DIY — there’s no first-class concept of a “project” with its own budget, roles, or environment segmentation.

LiteLLM

LiteLLM is a routing proxy, not a cost-allocation platform. It routes requests and tracks spend, but attribution by agent requires external tooling. You’d need to pipe logs into your own analytics stack and build the grouping yourself.

Langfuse

Langfuse is an observability platform. It traces LLM calls and can tag them with metadata, but it doesn’t enforce budgets, rate limits, or access control at the project level. It’s a viewer, not a controller.

OpenRouter

OpenRouter is a model marketplace. It routes to many models at competitive prices, but it doesn’t segment costs by project or agent. You get a single balance and usage history across everything.

What “Per-Project” Actually Means in Floopy

Floopy treats Projects as a first-class entity. A project represents an agent, a product feature, a team workstream, or any logical unit you want to track independently.

How it works

1. Create a project in the dashboard (e.g., “Checkout Agent”, “Search Reranker”, “Chat Assistant”)
2. Send a header with every request: floopy-project-id: <project-id>
3. Fallback chain: If no header, Floopy uses the API key’s default_project_id. If the key has a hard-locked project_id, that always wins.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.floopy.ai/v1",
    api_key="fl-your-key",
    default_headers={"floopy-project-id": "proj_checkout_abc123"},
)

That’s it. Every request is now tagged to a project, and every dashboard widget — cost, latency, quality, error rate — breaks down by project automatically.

Environment is a key property, not a project property

Projects are environment-agnostic. Instead, you assign an environment (development, staging, production) to each API key. This means you can create three keys for the same project — one per environment — and compare spend across environments natively in the cost-by-environment widget.

Per-project budgets and alerts

Set a monthly cost cap per project. Get alerted when a project hits 80% of its budget. Floopy returns 402 Payment Required when the cap is breached — no surprise bills.

Per-project roles

Grant a contractor access to just the “Search Reranker” project without exposing your organization’s other projects, keys, or billing data. The manager role can create projects and manage members without being an org admin.

Per-project feedback-driven routing

Because projects are a first-class entity, the routing decisions Floopy makes from session signal, auto-evaluations, manual ratings, and benchmarks are also scoped per project. The chat assistant and the document summarizer learn which models work best for their workload — not a blended average across every agent on the account.

A Hypothetical Case

Imagine you run an e-commerce platform with four AI-powered agents:

Without projects, you see $6,659/mo as a single number. With projects, you immediately see that the Checkout Agent is 43% of your total spend. You can then:

• Set a $3,000 budget cap on the Checkout Agent
• Compare its dev vs. prod cost to catch inefficient prompts before they ship
• Grant the checkout team access to their project’s dashboard without exposing other projects
• Route the Checkout Agent to a cheaper model once feedback confirms it holds up on checkout-specific prompts

Try It

Projects are available on all plans. Free includes 1 project, Starter includes 3, Pro includes 10, and Enterprise has no limit.

Point your SDK at api.floopy.ai, add the floopy-project-id header, and your next dashboard visit will show the breakdown.