Editorial note: Today’s picks cluster around the tooling layer that surrounds agent models — token optimizers, orchestration harnesses, and practical libraries that keep multi‑agent workflows running in the real world.
In Brief
Hello‑Agents: From zero to functioning agents
Why this matters now: datawhalechina’s hello‑agents repository is shaping how newcomers and teams learn practical, multi‑agent patterns for research and products.
datawhalechina’s tutorial repo — billed as “从零开始构建智能体” — continues to attract attention as a concise, example‑driven way to learn agent design and agent chains. With a heavy star count and rapid growth, the project is serving as a common onboarding path for students and engineers who want hands‑on agent experiments without starting from a blank slate. Expect this repo to keep appearing in developer reading lists and course syllabuses.
"《从零开始构建智能体》" — the repo’s pedagogical framing focuses on practical agent building over abstract theory.
Scrapling: adaptive web scraping for agent pipelines
Why this matters now: D4Vinci’s Scrapling gives agent stacks a resilient way to fetch and maintain data from the web, which is increasingly important for information‑seeking agents.
Scrapling positions itself as an adaptive scraping framework that can scale from single requests to full crawls and claims features like parsers that re‑locate when pages change. For agent builders who feed models with fresh web context, tooling that survives site drift is a productivity multiplier — and Scrapling’s test coverage and type hints make it attractive for production experimentation.
OpenHands: a developer control center for agents
Why this matters now: OpenHands’ OpenHands project aims to centralize developer control for running different agent runtimes and backends, reducing friction when teams try multiple models or deployments.
OpenHands bills itself as a self‑hosted dashboard for running Claude Code, Codex, Gemini, or other ACP‑compatible agents across local and cloud backends. For engineering teams juggling hybrid deployments, a single control surface lowers the operational mental load and makes A/Bing different agent stacks less painful.
Deep Dive
RTK — Rust Token Killer and the token‑savings controversy
Why this matters now: rtk‑ai’s rtk is getting massive adoption as a CLI proxy promising 60–90% token savings, and that claim is reshaping cost conversations for agent developers — even as independent benchmarks push back.
rtk presents itself as a "High‑performance CLI proxy that cuts up to 90% of the bash output your agent reads." The technical idea is simple and compelling: place a tiny proxy between your shell and an LLM‑driven agent so the model only receives the concise, cleaned output it actually needs. For tasks where terminal noise dominates model input, filtering and canonicalizing output can plausibly reduce tokens dramatically.
"High‑performance CLI proxy that cuts up to 90% of the bash output your agent reads." — from the rtk README
But the story has a wrinkle. Independent benchmarks reported by some firms and community members suggest that in some setups — notably with certain Claude Code workflows — wrapping the session with a proxy can actually increase session costs by changing model behavior or prompting more back‑and‑forth. One published benchmark reported a median session cost increase of 7.6% for specific workloads; other users report dramatic savings. That divergence matters: the efficiency of a token proxy depends heavily on the agent prompt structure, model choice, and session semantics.
Practically, here’s what to watch if you’re considering rtk:
- Try it on representative workloads first — microbenchmarks don’t always match your agent’s dialog dynamics.
- Measure both tokens saved and any change in model responses or retries; filtering can alter context in ways that cause more clarifications.
- Leverage rtk’s single‑binary, zero‑dependency Rust design for low operational overhead, but keep an eye on failure modes where the proxy hides useful debugging context.
The net: RTK is an important, high‑velocity project that forces teams to think about communication efficiency between tool outputs and models. But don’t treat the headline percentage as universal; run controlled tests before switching production pipelines.
DeerFlow 2.0 — ByteDance’s long‑horizon SuperAgent harness
Why this matters now: bytedance’s deer‑flow (DeerFlow 2.0) expands the capabilities of agent orchestration with sandboxes, subagents, memory, and skill composition — useful for long‑running, complex tasks that span minutes to hours.
DeerFlow is a purpose‑built orchestration layer for "long‑horizon" agent work: research tasks, code generation that needs iterative testing, or workflows that require tool use, stateful memory, and sandboxed execution. The README frames it as a SuperAgent that "researches, codes, and creates" by combining sandboxes, tool integrations, and subagents that can run in parallel or sequence.
"An open‑source long‑horizon SuperAgent harness that researches, codes, and creates." — from the DeerFlow README
Why this design matters: agents solving multi‑step problems need more than prompts — they need runtime management (timeouts, retries, isolation), modular skills that can be swapped or upgraded, and robust state management so a partially completed plan survives restarts. DeerFlow’s architecture acknowledges this, providing building blocks (memory, sandboxes, gateways) that make complex agent behaviors maintainable and auditable.
There are tradeoffs. As orchestration gets richer, attack surface and governance concerns grow. Teams adopting DeerFlow should decide which parts run on trusted infrastructure, how tool outputs are validated, and how long‑term memories are purged or protected. Still, for companies and research groups trying to move from toy agent demos to reliable, long‑running automation, DeerFlow 2.0 is a strong datapoint in the direction of industrial‑grade agent stacks.
Closing Thought
Agent infrastructure is maturing fast — not as a single killer app, but as a toolchain: token optimizers, robust scrapers, teaching repos, and orchestration layers. Each project above attacks a different friction point. The practical lesson for builders is to treat these pieces like plumbing: measure them carefully, integrate incrementally, and plan for the operational and safety implications as you scale.