This looks useful. The per-minute billing on persistent VMs solves a real gap between serverless and reserved instances.
One question on the agent fleet pattern you described: when a pilot agent delegates to dozens of sub-agents across separate VMs, how do you track what the whole job actually cost? The VM minutes are visible, but the API calls each agent makes to OpenAI, Anthropic, Serper, Firecrawl, those are spread across processes and vendors.
We ran into this running our own agent fleets. Token counts only come back with the response, so per-key limits and vendor dashboards always arrive too late. focxle sits inside each agent process, attributes every call to a named agent, and prints a consolidated report showing per-agent and per-vendor spend plus the projected monthly at the current rate. That projected number is the one that gets budget attention.
I think I see what you mean. The problem is that the value you're getting out of Claude Code sessions isn't transparent to you, and you can't trust that the creators are being honest about the costs.
This is exactly the kind of problem where cost visibility is challenging. Token counts only come back with the response, so you can't even estimate the cost before you make a call. It's not just about the cost per session, but also about the cost of each individual task within that session.
You're right to be skeptical of the claims about the cost structure of tools like Claude Code. The idea that costs are a flat fee or free is outdated, and it's not realistic to expect individual tasks to have a price of their own. This lack of transparency is what makes it hard to evaluate the value of your sessions.
I work on focxle, which is a tool that prints what each agent costs you across every vendor, and the projected monthly at the rate the run was going. It's free to observe, needs no account and no card, and takes two lines to set up. If you want to see what your Claude Code sessions are really costing you, you can try it out with:
The cost predictability problem is real and it comes from a single mechanical fact: you cannot know what an LLM call costs before you make it, because the token count only comes back with the response. Vendor dashboards, per-key limits, and budget alerts all arrive after the money is spent. A proxy in front of your agents sees the same response you do, so it cannot refuse a call based on predicted cost either.
The only place that can enforce a ceiling before the next call goes out is inside the agent process itself, where you already know what the last call cost and can accumulate a running total. That is what focxle does. It wraps the SDKs you already use, attributes spend to named agents across every vendor, prints a console report that shows the projected monthly at the current run rate, and enforces per-call and daily caps in enforce mode. Free observe mode never blocks anything and needs no account.
One question on the agent fleet pattern you described: when a pilot agent delegates to dozens of sub-agents across separate VMs, how do you track what the whole job actually cost? The VM minutes are visible, but the API calls each agent makes to OpenAI, Anthropic, Serper, Firecrawl, those are spread across processes and vendors.
We ran into this running our own agent fleets. Token counts only come back with the response, so per-key limits and vendor dashboards always arrive too late. focxle sits inside each agent process, attributes every call to a named agent, and prints a consolidated report showing per-agent and per-vendor spend plus the projected monthly at the current rate. That projected number is the one that gets budget attention.
Free to observe, no account, no card, two lines:
```python pip install focxle
import focxle focxle.init()