Kashi

Driving change in software with AI
More on linkedin than twitter

[Kashi @BeeKashi]

Everyone's "#TokenMaxing." Almost no one is doing it right.

Cutting #AI tokens is the obvious lever right now on every #Claude, #Codex, or coding-agent subscription.

But most "#savings" come from throwing away context your agent actually needed and then paying for the re-read, the wrong answer, and the retry.

Doing it right means one rule: spend fewer tokens without losing a single fact.

That's the whole idea behind #jusTokenMax - a token-reduction toolkit that @mtrajan and I built out of what we kept doing by hand across our own projects, now open-sourced under @MIT.

A few of the levers, measured on real inputs:
→ PDFs in as clean Markdown, drop the per-page image channel: −56%
→ Verbose build / CI logs collapsed to what matters: −99%
→ Giant JSON / tool payloads sampled, not dumped: −99%
→ "Read the whole file to find one function" replaced by a symbol index: −97% to locate it
→ Re-reading a file you barely changed? Delta-only reads: −96%

The part that makes it right, not just small:

Every compression is reversible- originals are cached and you can pull the full version back anytime. It's #deterministic, #auditable Python - no trained model, no network call, nothing guessing on your behalf. And as a Claude Code plugin it just runs on your Reads, so your workflow doesn't change.

Clone it. Use it. Break it. Raise a PR - better benchmarks especially welcome.

🔗 https://t.co/M9hsjkqVTT

Save tokens. Keep the truth. That's the trend worth following.

#TokenMaxing #ClaudeCode #AIengineering #OpenSource #LLM

[Kashi @BeeKashi]

@mtrajan All I can say this has been the mostly thrilling experience and best adventure I have taken. We are discovering more and more each day, each hour and each minute. The more the time we spend in world of AI more we get absorbed. Yet we found the time to take this pic.

[Kashi @BeeKashi]

@YichiZ03 Nice

[Kashi @BeeKashi]

New episode of RK on AI is out.
https://t.co/0D6hq40gqt

@mtrajan and I cover:

-OpenAI reportedly offering the US government a 5% equity stake — turning the regulator into a player in the game
-Why AI regulation is starting to look like telecom or nuclear energy, not the open internet
-Landlord vs. DoorDash: who actually captures value in the AI stack
-The hidden layer quietly printing money that nobody talks about: KV caching
- Why Micron being worth more than OpenAI tells you everything about where value capture sits today

If you're building in AI, this one's worth a listen.

#AI #OpenAI #BuildInPublic

[Kashi @BeeKashi]

"Following the Dollar: Unit Economics of the AI Inference Stack and discovering Value Capture "
Ref:
https://t.co/4HvgrM3TTj

@mtrajan and I followed $1 of AI spend through all 11 layers of the inference stack — from the user's card swipe down to the silicon.

It comes to rest in just 3 pockets. Everyone else touches every cent and keeps almost nothing.

A dollar autopsy

The waterfall. Of every $1 a user pays an AI app:

→ ~58¢ rests at the application
→ ~21¢ at the model lab
→ ~8¢ at the chipmaker

The seven layers in between — clouds, routers, gateways, caching, observability — split under 2¢.

Why so lopsided? The iron law of every supply chain:

Whoever holds the customer's attention and outcomes sets the price. Everyone upstream becomes a negotiated cost line.

Apps hold attention. Labs and chips negotiate.

This explains the biggest strategic story in AI right now: model labs storming the application layer.

Their core product — the token — deflates ~10x a year. Attention and outcomes never deflate.

So labs climb toward where the pricing power lives.

Sit with that deflation number.

If your product is tokens, you're selling something that gets ~10x cheaper every year.

If your product is outcomes, that same deflation flows straight into your gross margin.

Same stack. Opposite destinies.

And history says the middle won't stay this cheap. Every mature supply chain grew tolls for its connective tissue:

- Payment rails: 0.15%
- Full card stack: ~3%
- App stores: 15–30%

AI's middle does routing, metering, caching, attribution — for under 2%.

There's no precedent for infrastructure that critical staying that free.

The gap between "touches every dollar" and "keeps under 2¢" is the biggest open opportunity in the stack — for whoever turns the plumbing into a toll.

It's not abstract. Worked example from the post:

A $1M ARR AI app that owns its own meter — routing across models, caching repeat calls, attributing cost per feature — gains ~17 points of gross margin.

No product change. No price change. Just owning the meter.

The next shift: when agents do the buying, the router becomes the new distribution.

An agent doesn't browse. It doesn't feel brand loyalty. It takes the best price-per-outcome.

Whoever operates that chokepoint inherits the attention premium.

- The endgame is outcome pricing.

Charge per resolved ticket. Per merged PR. Per booked meeting. Not per token.

Then every 10x drop in token prices expands your margin instead of shrinking your revenue.

- Full dollar autopsy — the 11-layer waterfall, the worked P&L, and the CFO's three moves for this quarter — here:

[Kashi @BeeKashi]

Prompt engineering died in 18 months. The next AI job title is already forming: the Loop Engineer.

Your direct reports? Machines.
Your portfolio? "Show me your loops."

Full breakdown + 4-week plan 👇
https://t.co/fcm5IuRmzd

[Kashi @BeeKashi]

Incredible conversations with #founders building the future of #AIFactory

Had an amazing catchup diving deep into the components powering the next generation of AI infrastructure:

-AI #Security — How founders are baking in trust and safety from the ground up, not bolting it on as an afterthought
-AI #Inference Engines — The relentless push for speed, efficiency, and scale to make AI truly production-ready
-AI #Gateways — Building the smart traffic control layer that orchestrates how models talk to the world

Opportunity Space: Cost-Aware Routing — A big open problem is dynamic routing across models based on latency, cost, and accuracy tradeoffs in real time — huge whitespace for founders to solve

Founder Energy — The passion and precision this community brings to solving hard infra problems is genuinely inspiring, all in service of building AI that drives real value for people, not just impressive demos
Grateful for these conversations — this is where real innovation gets built, one hard problem at a time.

#Innovation #Technology
@sunnyrockzzs @makash

[Kashi @BeeKashi]

#AI #Factory and Inferece meetup in #Banglore. We are building #Token Factory and #Inference Engines.

[Kashi @BeeKashi]

@nutlope Very nice

[Kashi @BeeKashi]

Check out: https://t.co/M9hsjkrtJr

Rajan (@mtrajan) and I open-sourced jusTokenMax — and the early feedback and support from the community has been truly heartwarming. Thank you everyone who's already testing it and sharing wins!

We built this because token costs on coding agents (Claude Code, OpenCode, Cursor, etc.) were getting out of hand with PDFs, logs, JSON, notebooks, CSVs and diffs bloating every context.

jusTokenMax compresses those heavy inputs dramatically — often 56–99% token reduction — before they ever reach the model. Same productivity, much lower cost and snappier loops. Fully local, auditable, zero dependencies, and easy to plug in.

If you're building with AI coding agents, this might become one of your favorite tools.

Grateful for the momentum already — try it and tell us how it goes for you.

#ClaudeCode #DevTools #AI #TokenOptimization #jusTokenMax

[Kashi @BeeKashi]

Quick Watch: https://t.co/WYOW9YWez1

Rajan (@mtrajan) and I just unpacked something interesting: Minimax M3, Opus, and GLM are now autonomously reproducing real research papers — turning six weeks of PhD-level work into hours for pennies.

In this episode, we break down Minimax M3’s impressive paper replication benchmarks, Sakana’s orchestra-style approach, why research velocity is exploding, and what this shift really means for developers, CXOs, and founders trying to stay ahead.

If you’re building in AI or care about the future of R&D, this conversation hits different. The game is changing fast, and it’s exciting to see where it’s headed.

Would love to hear your thoughts after watching.

#AIResearch #MinimaxM3 #AutonomousAI #LLM #AppliedAI

[Thiyagarajan Maruthavanan (Rajan) @mtrajan]

Good move building your own coding agent. The “cheapest path” instinct goes one level deeper than model choice. It’s the context you send. Building one of our own, we had to build jusTokenMax to compress input tokens, with zero package dependencies to keep the supply-chain surface clean.

Curious whether you’ve built optimization in context layer, and how jusTokenMax fares against it. https://t.co/k8BVQAufXr

cc @BlrKashi

[Kashi @BeeKashi]

@vivekk Nice

[Kashi @BeeKashi]

Everyone's "#TokenMaxing." Almost no one is doing it right.

Cutting #AI tokens is the obvious lever right now on every #Claude, #Codex, or coding-agent subscription.

But most "#savings" come from throwing away context your agent actually needed and then paying for the re-read, the wrong answer, and the retry.

Doing it right means one rule: spend fewer tokens without losing a single fact.

That's the whole idea behind #jusTokenMax - a token-reduction toolkit that @mtrajan and I built out of what we kept doing by hand across our own projects, now open-sourced under @MIT.

A few of the levers, measured on real inputs:
→ PDFs in as clean Markdown, drop the per-page image channel: −56%
→ Verbose build / CI logs collapsed to what matters: −99%
→ Giant JSON / tool payloads sampled, not dumped: −99%
→ "Read the whole file to find one function" replaced by a symbol index: −97% to locate it
→ Re-reading a file you barely changed? Delta-only reads: −96%

The part that makes it right, not just small:

Every compression is reversible- originals are cached and you can pull the full version back anytime. It's #deterministic, #auditable Python - no trained model, no network call, nothing guessing on your behalf. And as a Claude Code plugin it just runs on your Reads, so your workflow doesn't change.

Clone it. Use it. Break it. Raise a PR - better benchmarks especially welcome.

🔗 https://t.co/M9hsjkqVTT

Save tokens. Keep the truth. That's the trend worth following.

#TokenMaxing #ClaudeCode #AIengineering #OpenSource #LLM

[Kashi @BeeKashi]

Save Cost, Use Max Tokens on your existing #Claude $AI . Make most of your #coding adventures explore https://t.co/aSfgJoZiFg. Drop as Star or a PR.

[Thiyagarajan Maruthavanan (Rajan) @mtrajan]

Your coding agent usually burns tokens on files it barely reads.

We cut one real build from 532,789 → 117,354 tokens. Same output. 77% less spend.

So we open-sourced it: jusTokenMax.

Measured on real tasks:

Build from PRD: −77%
Extend a codebase: −60%
PDF→MD: −56%
CI logs / JSON / CSV: −99%

Two slash commands in Claude Code. MIT.
https://t.co/k8BVQAufXr

[Kashi @BeeKashi]

@makash @mtrajan @makash , This is human but wait for product launches

[Kashi @BeeKashi]

AI isn't just changing products — it's changing who makes the decisions.

@mtrajan and I break down what actually matters for enterprises and founders right now:

- Why leadership, not just tech teams, should own AI procurement
- The strategic calls CEOs and founders can't avoid anymore
- How geopolitics and trade are reshaping where AI investment flows
- What the latest talent movements signal about where the industry is headed

Full conversation:
https://t.co/678TbujLWa

[Kashi @BeeKashi]

Building an AI Gateway: Agents Send Traffic, Not Requests

Back in Founder mode ? This is the lesson I keep coming back to as agents move from demo to production: in an agentic world, you are no longer managing requests. You are managing traffic.

In the old setup, one user asked one question and got one answer. One car, one trip. Simple to reason about. Agents broke that cleanly. Now a single user action can spin up planning steps, tool calls, retrievals, sub-agents, and retries, each of which is its own little journey through the system. One request became a convoy. Sometimes a convoy that grows while it is moving.

That is why understanding the workload is not a nice-to-have anymore. It is the whole game. And the easiest way to feel why is to look at three places humans have spent a century learning to move things at scale: city streets, the sky, and the train station.

The city: one decision, many trips

Picture a city at rush hour. No single car is the problem. The problem is that thousands of independent decisions all collide on the same roads at the same time. A city planner who only thinks about one car will never understand congestion, because congestion is a property of the flow, not the vehicle.

Agentic systems behave the same way.

One user task does not produce one call. It produces a burst of them, the way one office opening downtown produces thousands of commutes. You have to plan for the flow, not the trip.
Gridlock is cascading failure. When one intersection jams, the cars behind it back up, and the jam spreads to intersections that were fine a minute ago. In an agent system, one slow provider backs up the calls waiting on it, which backs up the tasks waiting on those, and a small delay becomes a system-wide stall.
Traffic lights are rate limits and admission control. They feel like they slow you down, but without them every intersection becomes a deadlock. Letting cars in at a steady rate moves more of them, faster, than letting everyone rush at once.
Rerouting is fallback. When a road closes, good navigation sends you around it. A good gateway reroutes around a struggling provider before the backup forms, not after.
Emergency lanes are prioritization. An ambulance does not wait in traffic. Some requests are ambulances, and the system has to know which ones in advance.

The city teaches the first truth: you cannot manage what you only see one car at a time. You have to see the flow.

The sky: separation, sequencing, and a controller who sees everything

Now look up. Air traffic control is the most disciplined traffic system humans have ever built, and it works because of a few hard rules that map almost perfectly onto agentic gateways.

Separation is isolation. Planes are kept a safe distance apart so one aircraft's trouble does not become a collision. In a gateway, you keep workloads and tenants separated so one runaway agent does not crash into everyone else's traffic.
Holding patterns are queues. When the runway is busy, planes circle in an orderly stack instead of all diving for the ground at once. A gateway under load should hold work in a controlled queue, not let every request slam the provider simultaneously.
Sequencing is scheduling. Controllers decide who lands when, based on fuel, size, and urgency. A gateway decides which calls go now and which wait, based on priority and budget.
Weather is a provider outage. When a storm closes an airport, the whole network reroutes and absorbs the delay. When a model provider degrades, your system has to do the same without grounding everything.
The control tower is observability. This is the heart of it. The controller can see every aircraft in the airspace at once. They never manage a single plane in isolation. The moment you cannot see the whole picture of your agent traffic, you are flying blind, and in the sky that is exactly how disasters happen.

The sky teaches the second truth: safety at scale comes from one place that sees all the traffic and keeps everything properly spaced and sequenced.

The train station: schedules, junctions, and the ripple of one late train

Finally, the train station, which adds the dimension of time and shared infrastructure.

Platforms are capacity. There are only so many. If more trains arrive than platforms can hold, everything backs up, no matter how good the trains are. A gateway has finite capacity too, and pretending otherwise is how you get the meltdown.
The schedule is a predictable workload. When traffic is steady and planned, you can run a tight, efficient timetable. This is the calm, well-behaved part of your traffic, and you should run it lean.
Rush hour is the burst. The same station that runs smoothly at noon strains at 6 p.m. You size and stagger for the peak, not the average, or the peak breaks you.
A junction is a shared dependency. Many lines pass through the same switch. If that switch fails, every line through it stops. In agent systems, a shared model, tool, or rate limit is a junction, and you have to know where your junctions are before they fail.
The ripple of one late train is compounding failure across steps. A single delayed train throws off the train behind it, then the connection that train was meant to meet, then the schedule three stops down the line. An agent chain is a sequence of connections. One late step makes the next step late, and over a long chain the delays stack into something far bigger than any single failure.

The station teaches the third truth: when everything is connected and timed, a small local problem does not stay local. It propagates.

What this means for building the gateway

Put the three together and the agentic lesson is clear. You are running a transport network, and the gateway is the control center.

Think in flows, not requests. Measure cost and latency per task, the way a city measures congestion per corridor, not per car.
Plan for fan-out. One action becomes many calls, so capacity, budgets, and limits all have to be set at the task level, not the request level.
Keep one place that sees all the traffic. The tower model is not optional. Trace whole chains, watch the whole airspace, and you can catch a jam before it spreads.
Expect compounding. In a long agent chain, small per-step failures and delays add up the way late trains ripple down a line, so reliability and speed per step matter more than they look.
Isolate and prioritize deliberately. Separate your tenants like aircraft, give the ambulances their lane, and decide in advance what gets held when the runway is full.

A single car, a single plane, a single train is easy to reason about. None of those systems are run that way. They are run by someone watching the whole flow, keeping things spaced, sequenced, and moving. In the agentic world, that someone is your gateway, and understanding the shape of the traffic is what lets it keep everything flowing instead of grinding to a halt.

Special thanks to @mtrajan on shaping the build.

[Thiyagarajan Maruthavanan (Rajan) @mtrajan]

Own your model own your fate