A recent project sparked notable attention on Hacker News: Semble—a code search tool billed as “designed for Agents”—claims to complete code search tasks using 98% fewer tokens than grep.
283 points, 96 comments. For a code search tool, that level of engagement is remarkably high.
But what truly warrants writing about isn’t the tool itself—it’s the underlying trend it exemplifies: an increasing number of new tools are targeting AI Agents—not human developers—as their primary users.
What Does a 98% Token Reduction Actually Mean?
First, let’s clarify the problem Semble solves.
When an AI Agent needs to understand a codebase, it typically searches files, reads content, and infers context. Using traditional grep + file-read workflows, the Agent consumes large numbers of tokens—even reading content it doesn’t actually need.
Semble instead returns only the precise code snippets the Agent requires, rather than entire files. As a result, token consumption per search drops dramatically.
A 98% token reduction sounds extreme—but in AI Agent scenarios, it’s entirely plausible. Human developers can “glance and grasp” what’s relevant; AI Agents must read every token—unless someone pre-filters for them.
A Larger Trend Is Underway
Semble is no outlier.
Over the past few months, the AI Agent toolchain has expanded at a visible, accelerating pace:
- Code search: From
grep(human-readable results) to Semble (structured, Agent-readable output) - Code navigation: From click-driven file trees (for humans) to code graphs (consumable by Agents)
- Testing tools: From human-viewable test reports to evaluation signals parseable by Agents
- Documentation tools: From Markdown docs (for humans) to structured knowledge bases (for Agents)
What unites these tools? Their user is the AI Agent—not the human developer.
This signals a foundational shift: the design paradigm for developer tools is evolving from “human-first” to “Agent-first.”
This Isn’t Necessarily Bad—But It Changes the Rules
Some may find this trend unsettling: tools are no longer designed for people, but for machines.
Yet viewed differently, it’s an inevitable consequence of technological progress.
Just as compilers aren’t written for humans (assembly language is), but for machine execution—and IDEs aren’t built for machines, but for human interaction—each layer of abstraction emerges to serve the needs of a specific actor.
The rise of AI Agent toolchains reflects a simple reality: AI Agents have become a new actor in the code world. They need tools tailored to them—just as human developers need IDEs.
But It Also Raises Important Questions
First, declining observability. When tool outputs are optimized for Agents, how do human developers understand what the Agent is doing? If a search tool returns structured, Agent-friendly data, can humans still interpret it?
Second, tool fragmentation. Will we soon need two parallel toolchains—one for humans, one for Agents? Could this increase maintenance overhead?
Third, what defines quality for Agent tools? Human tools are judged by UX. But what is the “UX” for an Agent tool? Token efficiency? Accuracy? Latency? Something else entirely?
A Possible Future: Agent-First, Human-Friendly
The ideal path forward may be “Agent-first, Human-friendly”: tools optimized under the hood for Agents, yet offering interfaces readable and usable by humans.
Think of the relationship between APIs and dashboards: APIs are designed for machine consumption; dashboards help humans understand what’s happening.
Semble currently ships as a CLI tool with structured JSON output. That’s promising—structured output serves Agents directly and can be rendered into human-readable formats by companion tooling.
This layered architecture may well become the gold standard for future Agent toolchains.
Closing Thoughts
Semble’s 283-point HN score isn’t due to technical breakthroughs—it’s because it captures a trend already in motion.
AI Agents are no longer theoretical. They’re becoming citizens of the code world. And designing tools for them is rapidly emerging as the new frontier—and battleground—in the developer tools industry.
For developers, this raises a critical question: Who is your tool built for?
Humans—or your AI colleagues?
Increasingly, the answer may no longer be binary.