Teaching an AI agent your domain's rules by hand works for a few — but does it survive hundreds?
Does codifying domain rules into agent scaffolding work at library scale?
This explores whether hand-writing domain rules into an agent's harness (its prompts, tools and workflow templates) keeps working as the rules, domains and tasks grow from a handful into a large library.
This explores whether hand-writing domain rules into an agent's harness keeps working as the rules, domains and tasks pile up into a library. The corpus has no note that tests this directly, so what follows is pieced together from neighbouring work. The pieces point one way: codified rules pay off where they are stable and checkable, but hand-curating and hand-wiring them is the part that stops scaling.
The closest evidence is a study that ran automated optimization loops across many environments. It found four harness mechanisms (action execution, context compaction, observation handling and delegated reading) that cut token traffic by roughly 45–49% on a 51-task benchmark at comparable performance, and the gains were independent of model improvements (Can agent harnesses be automatically optimized across many environments?). The mechanisms that held up across that many environments were general plumbing found by search, not domain rules someone wrote down. That framing also gives a fair test. Multi-agent performance turns out to be largely a token-spending function, with about 80% of the variance coming from budget (How does test-time scaling work at the agent level?). A large rule library that mostly adds prompt text may just be buying tokens, so its benefit should be judged at equal cost.
Codifying does have a strong form. Code is executable, inspectable and stateful, so a rule written as code can be run and checked, while a rule written as prose can only be hoped for (Can code serve as the operational substrate for agent reasoning?). Where rules are precise and repetitive, small models can handle the resulting subtasks at 10–30× lower cost than large ones (Can small language models handle most agent tasks?). A verified rule layer can therefore be both trustworthy and cheap to run.
The strain shows up in three places. First, a rule library is capped by its author's imagination. Agents trained on expert demonstrations are limited to what curators imagined (Can agents learn beyond what their training data shows?), and hand-written rules plausibly inherit the same ceiling. That is an extrapolation, not something the note tests. Systems that generate a workflow per query, rather than reusing fixed task-level templates, are one response to it (Can AI systems design unique multi-agent workflows per individual query?). Second, finding the right rule becomes the bottleneck. Semantic capability vectors make discovery scale sub-linearly as the pool grows, and manual wiring does not (Can semantic capability vectors replace manual agent routing?). Third, the natural fix of splitting domains across specialized agents (Do single agents always hit organizational limits?) brings its own cost. Coordination degrades predictably with network size, and agents accept neighbours' information without checking it (Why do multi-agent systems fail to coordinate at scale?). A wrong rule passed between agents can spread rather than get caught.
The corpus suggests a practical rule of thumb. Codify what is stable and verifiable, retrieve rules instead of wiring them in by hand, and let automated search find the general mechanisms. The corpus has no direct evidence on whether a hand-built library of domain-specific rules holds up at scale.
Sources 9 notes
Cross-environment harness optimization yielded four mechanisms (action execution, context compaction, observation handling, delegated reading) that reduced token traffic by 44.7–49.0% while maintaining comparable performance on a 51-task benchmark, suggesting harness-level gains are orthogonal to model improvements.
Research shows 80% of multi-agent performance variance comes from token budget, not coordination intelligence. LatentMAS and shared-KV-cache approaches offer ways to decouple performance gains from token costs.
Research shows code uniquely enables agent reasoning, action, and verification by being simultaneously executable, inspectable, and stateful. This unified code-centered loop improves reasoning and verification together compared to natural-language or prose-based approaches.
SLMs handle the repetitive, well-defined language tasks that constitute most agent work at 10–30× lower cost than LLMs, making heterogeneous architectures (SLMs by default, LLMs selective) the economically rational design pattern.
Agents trained on static expert datasets cannot learn from their own failures or generalize beyond demonstrated scenarios because they never interact with environments during training. Competence is capped by what curators imagined, not by agent capacity.
Show all 9 sources
FlowReasoner demonstrates that meta-agents trained with reinforcement learning and external execution feedback can generate unique multi-agent architectures for each user query, optimizing across performance, complexity, and efficiency—moving beyond fixed task-level workflow templates.
Versioned Capability Vectors embedded in HNSW indices couple semantic matching with policy and budget constraints, making capability discovery a first-class operation that scales sub-linearly as agent heterogeneity increases.
Research shows that real-world tasks requiring heterogeneous expertise, parallel execution, and independent verification exceed what any single agent loop can organize. Graph-based system abstractions are needed to distribute intelligence across specialized agents.
AgentsNet benchmark shows agents fail to coordinate strategies either by agreeing too late or adopting strategies without informing neighbors. Agents accept neighbor information without verification, enabling error propagation while remaining capable of detecting direct conflicts.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Towards a Science of Scaling Agent Systems
- How we built our multi-agent research system
- From Model Scaling to System Scaling: Scaling the Harness in Agentic AI
- Drop the Hierarchy and Roles: How Self-Organizing LLM Agents Outperform Designed Structures
- MUSE-Autoskill: Self-Evolving Agents via Skill Creation, Memory, Management, and Evaluation
- Harness Updating Is Not Harness Benefit: Disentangling Evolution Capabilities in Self-Evolving LLM Agents
- Single-Agent LLMs Outperform Multi-Agent Systems on Multi-Hop Reasoning Under Equal Thinking Token Budgets
- Scaling Behavior of Single LLM-Driven Multi-Agent Systems