DEV Community: Kushagra

AgentCost!!

Kushagra — Thu, 19 Feb 2026 03:45:00 +0000

One of the first feature requests after launching AgentCost came from an early user asking for OpenAI SDK support alongside LangChain tracking.

Interesting reminder that observability tooling has to extend beyond frameworks into direct provider integrations.

Working on expanding instrumentation coverage next.

Built AgentCost

Kushagra — Tue, 17 Feb 2026 04:00:00 +0000

Zooming into the SDK layer behind AgentCost.

Instead of asking devs to rewrite agents, it intercepts model calls and captures:

• Tokens
• Provider metadata
• Latency
• Usage context

Telemetry is batched + sent async so execution isn’t blocked.

Instrumentation without intrusion was the key design goal.

Built AgentCost

Kushagra — Mon, 16 Feb 2026 03:55:00 +0000

Now that AgentCost is live (https://agentcost.tech), I’ve been documenting the architecture behind the observability layer.

Telemetry flows from SDK instrumentation into ingestion pipelines that normalize pricing and compute workflow-level cost attribution.

Interesting how cost tracking quickly becomes a systems design problem.

Launching AgentCost

Kushagra — Sun, 15 Feb 2026 04:56:29 +0000

I Built AgentCost: Real-Time Cost Tracking for LangChain Agents

The Problem

Last month, my LangChain agent cost me $800 in OpenAI fees.
I had no idea which agent was expensive. No idea where to optimize.
I was flying blind.

The Solution

I built AgentCost - an open-source tool that tracks every LLM call your agents make.

How It Works

AgentCost works by intercepting LangChain's LLM calls using Python's monkey patching...

Architecture

Three components:

Python SDK - Intercepts calls
FastAPI backend - Stores data
React dashboard - Visualizes costs

Results

After using AgentCost for 2 weeks:

Identified that my "Router Agent" was called 10x more than needed
Switched simple queries to GPT-3.5 instead of GPT-4
Reduced costs from $800/month to $450/month (44% savings)

Technical Challenges

Monkey patching without breaking user code
How I solved: ...
Accurate token counting
The challenge: Different models use different tokenizers...
Batching for performance
The solution: Hybrid batching (size + time-based)...

Try It Yourself

AgentCost is open source and free to use:

GitHub: https://github.com/agentcost-ai/agentcost-sdk
Docs: https://agentcost.tech/docs/sdk

pip install agentcost

What's Next

Cost alerts (Slack/email when threshold hit)
Automatic optimization suggestions
OpenAI and Antropic sdk support

Feedback Welcome

If you try AgentCost, I'd love to hear your thoughts!

Twitter: @KushagraA15
GitHub: github.com/agentcost-ai

Building AgentCost

Kushagra — Wed, 11 Feb 2026 15:27:09 +0000

Working on the SDK instrumentation layer of my AI agent cost observability platform has been eye-opening.

Capturing token usage sounds simple until you try doing it across async chains, retries, and streaming responses without adding latency.

Developer tooling lives or dies on invisibility.

Building AgentCost!

Kushagra — Tue, 10 Feb 2026 14:07:00 +0000

One unexpected part of building an AI agent cost observability system has been designing the admin control plane.

User dashboards focus on agent spend.

Admin systems focus on telemetry pipelines, pricing integrity, and ingestion health across tenants.

It’s less analytics UI, more infrastructure operations.

Building AgentCost!

Kushagra — Mon, 09 Feb 2026 07:50:07 +0000

Working on cost observability for AI agents has been shifting how I think about system design.

Cost isn’t just usage data; it’s architectural feedback.

Agent decomposition, model routing, and retry logic all of it leaves a cost signature.

Instrumenting that layer is turning out to be as interesting as building the agents themselves.

Building AgentCost!

Kushagra — Fri, 06 Feb 2026 08:44:00 +0000

I’ve been working on production AI agents recently, and something became obvious very quickly:

We have great tools for tracing execution…
But almost nothing for tracing cost.

You can see prompt logs.
You can see model outputs.
You can debug chains.

But when your LLM bill spikes, you’re left guessing.

Which agent caused it?
Which model was overused?
Where should you optimize?

That gap pushed me to start building a cost observability layer specifically for agent systems.

The goal isn’t just analytics - it’s attribution:

Cost per agent
Cost per workflow
Cost per tool invocation
Real-time token burn rates

Still early, but architecturally it’s been one of the more interesting infra problems I’ve worked on in AI so far.