Cisco's "Unlimited AI Tokens" Flex: What It Really Costs

If you run an engineering budget, the number that should stop you isn't "unlimited." It's the one nobody at Cisco has published yet. On October 30, 2026, Fortune reported that Cisco president and chief product officer Jeetu Patel handed a 27-year-old engineer unlimited AI tokens to rewrite 98% of the company's legacy code, with the instruction to "go nuts." The story hit #8 on Hacker News inside 24 hours. Everybody quoted the flex. Nobody did the math.

So I did. I maintain a live LLM pricing tracker and a set of agent cost calculators on this site, and I run a multi-agent pipeline that burns real tokens every day. The surprising part isn't that "unlimited" is expensive. It's that for a two-person team, the token bill is a rounding error against a $461 billion company. Which means the actual risk Cisco signed up for has nothing to do with the token tap at all.

What is Cisco's unlimited AI tokens experiment

Cisco's unlimited AI tokens experiment is a company mandate that gives one engineer an uncapped budget of AI model tokens to refactor the company's legacy codebase with agentic coding tools, instead of metering usage against a fixed seat or spend limit. Cisco president and chief product officer Jeetu Patel handed that blank check to engineer Padmanabhan "Paddy" Krishnamurthy, and his framing, as reported by Fortune's Orianna Rosa Royle, was blunt: "I've given him unlimited tokens because he's going to refactor code... you can go nuts."

The target is big.

Patel says Krishnamurthy and a two-person team are rewriting 98% of Cisco's legacy code. The tools this runs on have matured fast. Anthropic's agentic coding CLI has crossed 154,000 GitHub stars and ships near-daily releases (v2.1.316 as of October 31, 2026). Having built the cost calculators and the multi-agent pipeline on this site, I've watched how fast an uncapped agent loop burns tokens in practice, so my first question isn't whether the capability is real. It is. My question is what happens when you point it at networking firmware with a famously long rap sheet of CVEs and remove every budget signal that would normally tell you when something has gone wrong.

The Hacker News thread, 230 points and 277 comments in a day, split along exactly that line. Half celebrated the ambition. Half asked whether an AI-driven rewrite of Cisco's code, done without sustained engineering discipline, would reintroduce the same bug classes within a year.

Who is Paddy Krishnamurthy, and why Patel picked him

Krishnamurthy, 27, joined Cisco in 2025 when the company acquired EzDubs, the real-time-translation startup he cofounded in 2023. Before this assignment, Patel describes him as "buried away in the organization doing something unstrategic," sitting five levels below the president on the org chart. The narrative Cisco is selling is irresistible: a founder-turned-IC, plucked from obscurity, handed a blank check to modernize the mothership.

That's the part I'd push back on first. Not because Krishnamurthy isn't capable (former founders who sold a startup to Cisco usually are) but because "two people rewrite 98% of legacy code" is doing a lot of load-bearing work in a sentence that no one has defined. Ninety-eight percent of which code? Cisco ships operating systems, router firmware, collaboration platforms, and security products across decades of acquisitions. If "legacy code" means one product line's service layer, two engineers plus agents is plausible. If it means the C/C++ that runs on actual switches, it is not, and no amount of tokens changes that.

One HN commenter described spending roughly $150 reverse-engineering a Cisco router firmware image with an LLM and finding the legacy C/C++ "horrifying" to read but genuinely solid at the memory-safety level, while noting the maintenance cost "must be enormous." That's the real texture of legacy networking code. Ugly, battle-tested, and load-bearing in ways a rewrite discovers only after it ships. This is the same dynamic I wrote about in AI coding agents won't replace you: the agent compresses the typing, not the understanding.

What unlimited AI tokens actually cost at enterprise scale

Here's the cost model nobody published. Per-token price comparisons mislead without cache-hit and retry assumptions baked in, and that's the first thing I learned building the LLM pricing tracker and agent cost calculators on this site. So let me bound "unlimited" with real numbers.

Current frontier agentic-coding pricing sits around $3 per million input tokens and $15 per million output for a mid-tier model like Claude Sonnet 4.5, climbing to roughly $15/$75 for a top-tier reasoning model. Prompt caching cuts the input side by up to ~90% on repeated context. Those three numbers are all you need to bound "unlimited."

An agentic refactor loop is context-hungry. Pulling in repo files, prior diffs, test output, and tool schemas, a single serious loop runs ~150K input tokens and ~15K output. That's about $0.68 uncached, closer to $0.20 with aggressive caching. Multiply that across how a "go nuts" engineer actually works, with parallel agents running most of the day, and you get this:

Take the pessimistic end. Two engineers running unbounded on a top-tier model, parallel agents, no caching discipline: call it $240,000 a month, or roughly $2.9M a year. That sounds huge until you set it next to a company with a ~$461 billion market cap and tens of billions in revenue. Cisco's "unlimited" token bill for this team rounds to zero on the income statement. The flex is free precisely because it's small.

The trap isn't the sticker price.

It's that "unlimited" removes the one signal that catches runaway behavior. Token spend is the smoke alarm. When you disconnect it, the retry loop, the context-bloat regression, the agent stuck re-reading the same 200K-token repo forty times, none of it pages anyone. I break the per-loop math down further in AI agent cost per task, and the harness-overhead piece specifically, how to measure AI coding agent harness overhead. Running this blog's own pipeline taught me two things the hard way. Deterministic cost gates before an expensive model call catch more than doubling the model's size does, and matching the model to the job shape (Sonnet for tool loops, Opus for prose) beats running everything on the priciest reasoning model. If you want the cheaper version of that lesson, reduce LLM API costs in production AI with caching and labeling before you ever talk about "unlimited."

How enterprises actually meter AI coding spend

Cisco's "unlimited" framing is an outlier, and that's the tell. Most enterprises running agentic coding at scale do the opposite. They meter aggressively, because the spend is wildly unpredictable per engineer.

The common pattern in 2026 is tiered budgets: per-seat soft caps, team-level hard caps, and dashboards that attribute every call to a cost center. GitHub Copilot's enterprise tier, for instance, bills a predictable $39 per user per month precisely so finance can forecast it. The moment you move to raw API access with agentic loops, that predictability evaporates and usage can swing 50x between a light and a heavy user. Exactly the range in the table above.

Netflix's internal approach is the one I'd copy: route by task shape, cap retries, and measure cost per completed task instead of per token. I wrote that up in Netflix Headroom, where cost-per-task optimization cut agent spend roughly 10x.

Serious shops treat token budgets as an observability problem, not a generosity problem. "Unlimited" optimizes for the headline. A labeled, capped, attributed budget optimizes for the quarter when something breaks. One of those is a recruiting slogan. The other keeps your LLM cost legible the day an AI agents loop goes sideways at 2 a.m. and nobody can tell which feature is burning the money.

The guardrails "go nuts" mandates still skip

Unbounded token usage fails in a specific, documented way, and it has nothing to do with your model being too small. Karthigayan Devan, a Google Developer Expert, published a postmortem of a platform team whose Vertex AI spend roughly tripled overnight. The cause: a stricter review-step prompt triggered a retry loop where each rejection re-sent the full ticket history plus the prior draft plus the review notes, so context and cost compounded on every cycle. Root cause took 2 hours 14 minutes to find, because no model call carried a request label. The bill couldn't be sliced by feature or team. The AI bill, quite literally, had no owner.

Then there's the overhead you pay before any work happens. Sarvar Nadaf, an AWS Community Builder, measured that GitHub's official MCP server loads about 55,000 tokens across 93 tool definitions, over a quarter of a 200K context window, before a single question is asked. Rebuilding it from 15 tools down to 4 cut tool-schema size by 88% and dropped the tool calls needed from 7 to 2. "Unlimited" hides that waste completely. You never see the quarter of every context window you're setting on fire.

So here's the guardrail set a "go nuts" mandate needs, none of which Cisco mentioned:

1. Cost-attribution labels on every API call so spend can be sliced by engineer, feature, and agent run. Without this you cannot diagnose a runaway loop; you can only watch the invoice grow.
2. Retry and loop caps — a hard ceiling on review-rewrite cycles, so a strict prompt can't compound context into a five-figure afternoon.
3. Test-coverage thresholds as merge gates. AI-rewritten code that drops coverage doesn't ship, full stop.
4. Human review gates on security-sensitive paths. Not optional on networking firmware. Pair this with a real AI code review checklist.
5. Rollback plans per subsystem, because the failure mode of a rewrite isn't "it doesn't compile." It's "it compiles, passes tests, and quietly breaks threading six weeks later."

That last one is not hypothetical. An HN commenter noted a prior AI rewrite where translated code shipped "without understanding" and caused a threading-related security bug. Given Cisco's history (hundreds, arguably thousands, of CVEs, hardcoded passwords, hidden support accounts) the AI security exposure of an unsupervised rewrite is the real bill, and it's denominated in incidents, not dollars. Prompt injection and insecure-pattern reintroduction are exactly the bug classes agentic rewrites are prone to. This is the vibe coding tech-debt problem at Fortune 500 scale, and it's why I lean on structured review for anything agentic, the same discipline behind AI agents in general and tools like Claude Code specifically.

The Gen Z and entry-level jobs nerve Cisco hit

The reason this story went viral isn't the economics. It's the subtext. Patel's bet lands in the middle of a labor narrative where entry-level jobs are vanishing and, per Fortune's reporting, roughly 40% of bosses say they plan to hire fewer new graduates because AI can do the work more cheaply. A sitting Fortune 500 president publicly elevating one 27-year-old over his veterans, and saying he's "fine with the tension that causes," reads to a lot of engineers like the quiet part said loud.

I don't think the framing is quite right, though. The Cisco story isn't "AI replaces engineers." It's "one trusted engineer plus agents replaces the throughput of a much larger team," which is a leverage story, not a headcount story. The person Patel picked wasn't a new grad. He was a founder who'd already shipped and sold a product. The judgment to know what 98% of a legacy codebase should become is the scarce input here, and agents don't supply it. They supply the typing. The gap between those two things is the whole job now, as I argued in agentic AI terms elsewhere on this site.

My prediction: within a year, Cisco quietly adds the guardrails it didn't announce. Labels, caps, coverage gates. Not because the token bill blew up, but because an AI-rewritten subsystem shipped a regression that made the news. "Unlimited" will turn out to have been a recruiting line and a press hook, not an operating model. The companies that win the legacy-modernization race won't be the ones that removed the budget signal. They'll be the ones that kept it, labeled every call, and spent the saved attention reviewing the code an agent can't be trusted to understand. Open the tap all the way, sure. But keep your hand on the valve.

Photo by Jordan Harrison on Unsplash.