Your AI agent just blew 140,000 tokens on a weather check. Now you can see why.

Alibaba Cloud released Agentic OS (ANOLISA) in March, calling it the industry's first agent-oriented operating system. The reception was enthusiastic, but the most frequent question from users cut straight to the bottom line: How do I minimize token consumption? The question also highlights a broader tension, the gap between prototype and production is still painfully human.

The question hides a deeper problem. Token consumption in multi-agent systems has long been a black box. You see a total at the end of the month but no breakdown of which agent, which step, or which decision branch ate the budget. That invisibility is now a liability as agent deployments scale from toy demos to production workloads handling tickets, inspections, and customer requests around the clock. Alibaba's own bet on agent infrastructure, including a $53 billion infrastructure plan, shows how seriously the company takes this scaling problem.

Enter AgentSight, the observability widget Agentic OS launched in its latest update. AgentSight promises to turn that black box into a transparent ledger with session-level and dialog-level granularity, real-time alerting, and full-chain trajectory playback. The tool is both a debugging aid and, potentially, an economic necessity for any team running AI agents in production.

What you can't see, you can't cut

AgentSight's visualization panel addresses the fundamental tension in agent operations: you let agents run 24/7, but you can't watch them around the clock. The old pattern was a silent background crash discovered the next morning, or a critical job interrupted without any alert. The new panel makes agent health visible at a glance, which agents are online, which are offline, which are stuck, refreshed in real time from global overview down to individual conversations.

When an agent goes offline or hangs, AgentSight doesn't just flag the error. It automatically sends an alert and can trigger a restart, cutting manual intervention. Every heartbeat is exposed.

The 140,000-token weather check

The real killer is token waste. AgentSight's fine-grained tracking reveals how quickly innocuous tasks can hemorrhage compute. The widget's documentation cites a deceptively simple test case: a user asks "Today's weather in Hangzhou."

Expected consumption: a few hundred tokens for the system prompt, maybe a couple thousand for a single tool call and response. Actual consumption: 140,000 tokens. That is not a typo.

Drilling into the data, AgentSight shows that even this single-turn query triggered two LLM calls as the agent fetched the weather skill and then queried the actual weather. Each additional tool call replays the entire message history, causing input tokens to climb linearly or super-linearly as the context window is repeatedly re-read. The agent isn't doing more work. It's paying the same toll every time it crosses a bridge. This dynamic echoes a problem researchers tackled with latent space recursion, aiming to cut the communication overhead between agents.

Through AgentSight's per-event inspection, users can see exactly which step consumed which portion of the budget. The system prompt dominates initially, then the swelling history window takes over. The tool breaks token consumption into two levels:

• Session level: How many tokens each agent consumes per session, displayed as a single graph showing global distribution. Outliers, an agent running 10x the mean, become immediately visible.
• Dialog level: A single dialog chain, tracking token change trends across the conversation. Was a specific skill invocation particularly verbose? Is the history window bloated? Every token is accounted.

Users can also compare trends across time segments and agent dimensions, how much was spent last week versus this week, and which day saw abnormal fluctuations.

From total bill to detailed ledger

After identifying how much was spent and where it went, AgentSight adds trajectory analysis: full-chain playback from task intake, through tool calls and decision branches, to final output. You can replay which skill the agent invoked at which node, which branch it took, and which stage consumed the most context window. Once the redundant paths are visible, you can optimize the agent's behavior design with intent, turning ineffective tokens into real savings. This kind of transparency aligns with Alibaba's broader philosophy of visibility over magic.

This is the first time Alibaba has brought such granular cost observability to an agent platform at the OS level. The tool is available both on Alibaba Cloud and for on-premises deployment via GitHub, with setup instructions provided in the Agentic OS documentation.

Why this matters

Agent cost overruns are not unique to Alibaba's ecosystem. As AI agents move from demos to production, token bills routinely shock teams that underestimated the compounding effect of long context histories and repeated tool calls. The cost side of agent operations has received far less attention than safety, but it's just as critical for sustainable deployment. For anyone running agents in production, AgentSight transforms tokens from an end-of-month shock into an actionable metric. You still have to optimize the agent's logic, but at least now you can see where to start. The lesson applies universally, the ten rules that separate AI coding agents from expensive guesswork all start with the same thing: visibility.