When AI agents build their own shortcuts instead of using tools made for humans, do they get faster and better, or sloppier?
Do agent-created languages improve or degrade performance on their original tasks?
This explores what happens when agents invent their own interfaces, notations, or communication channels (custom APIs, harnesses, shared message spaces) instead of using human-designed ones, and whether that helps or hurts on the original task. The corpus has no study of emergent languages as such, so this reads the question through the nearest material.
This explores what happens when agents invent their own interfaces, notations, or communication channels instead of using human-designed ones, and whether that helps or hurts on the original task. The corpus has no direct study of emergent agent languages. The closest evidence is about agents building their own interfaces and scaffolding, and it points to "usually helps, but only when you check the right things."
The clearest win is an agent-built shortcut. In the AXIS framework, agents explore an application and construct APIs for it, so they no longer step through the UI one click at a time. Task completion time dropped 65–70% while accuracy stayed at 97–98% (Can API-first agents outperform UI-based agent interaction?). Here the agent-made interface didn't trade away quality for speed. The corpus's broader account of reliability fits this. Agents get more dependable when memory, skills, and protocols are moved out of the model's head and into a durable structure (Where does agent reliability actually come from?). Self-improving agents mostly work this way too. Recent progress is concentrated in the fast loop that rewrites prompts, memory, and tools, because those changes are cheaper and reversible compared with changing weights (Do self-improving agents really split into two distinct loops?).
The warning is that an agent's self-made scaffolding is not reliably good. When models are asked to build and evolve their own harnesses, quality varies sharply across domains. The models also struggle to keep the useful intermediate updates, and a harness's performance shifts a lot depending on which model executes it (Can language models build and maintain their own agent harnesses?). So a language or tool one agent invents may not carry over to another agent. The same paper argues you can't judge a harness by downstream task scores alone. Harness improvement can be real and portable. One optimized runbook lifted several frozen models on Terminal-Bench 2.1 and transferred to newer models unchanged (Can execution harnesses lift model performance without retuning weights?). That shows the gap between the two outcomes is the quality of the process that produced the scaffold, not whether an agent made it.
There are two ways to misjudge the result. First, a gain may come from spending more, not from the new language. One note reports that about 80% of multi-agent performance variance comes from token budget rather than coordination cleverness, and it points to latent and shared-cache communication as ways to separate the two (How does test-time scaling work at the agent level?). Any claim that an invented protocol "improved performance" should show it wasn't just buying more tokens. Second, success rate can hide the damage. Identical success rates can conceal large differences in efficiency, reliability, and memory hygiene (How should we measure agent system performance beyond task success?). An agent language might hold accuracy steady while quietly getting more brittle or expensive.
The most striking case is one nobody designed. Short-lived agents turned a shared package repository into persistent memory by writing and reading findings across their lifespans (Can ordinary infrastructure become unplanned agent memory?). Agents will invent a shared channel on their own when they need one. The summary doesn't say whether it helped their scores, which is the kind of gap this question is about. The corpus suggests two things: agent-made interfaces can give large efficiency gains, and their effect on the original task is rarely measured directly.
Sources 8 notes
The AXIS framework shows that prioritizing API calls over sequential UI interactions cuts task completion time by 65–70% while maintaining 97–98% accuracy and reducing cognitive workload by 38–53%. A self-exploration mechanism automatically discovers and constructs APIs from existing applications, solving the bootstrapping problem.
Research shows reliable LLM agents externalize three cognitive burdens—memory (state persistence), skills (procedural components), and protocols (structured interaction)—into a harness layer rather than relying on model scale alone. The harness unifies these externalities and eliminates the need for the model to solve the same problems repeatedly.
A survey framework organizes self-improving agents into two update mechanisms: slow parametric loops updating foundation model weights, and fast non-parametric loops updating prompts, memory, and tools. Recent progress concentrates in the fast loop because scaffold updates are cheaper and reversible than weight updates.
Research shows that LLMs vary sharply in building harnesses across domains, struggle to retain useful intermediate updates during evolution, and produce harnesses whose performance shifts dramatically with different executors—demonstrating that harness quality cannot be inferred from downstream task scores alone.
StateM improves Terminal-Bench 2.1 accuracy across multiple models by optimizing execution systems around frozen weights. The same runbook transfers to newer models without modification, achieving 95.3% on GPT-5.6 and lifting DeepSeek-V4 Flash by 5.4 points.
Show all 8 sources
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.
Single task-success metrics obscure how agents achieve results across memory, context, and verification layers. Research shows identical success rates can mask enormous differences in efficiency, reliability, and deployment readiness—requiring harness-level benchmarks that measure trajectory, memory hygiene, and verification costs.
During a 2026 evaluation, short-lived AI agents repurposed a shared package repository as memory by writing and reading exploit findings across agent lifespans. The agents converted ordinary infrastructure into persistent state without deliberate memory system architecture.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- From Model Scaling to System Scaling: Scaling the Harness in Agentic AI
- Harness Updating Is Not Harness Benefit: Disentangling Evolution Capabilities in Self-Evolving LLM Agents
- Rethinking the Evaluation of Harness Evolution for Agents
- RRSI: Regularized Recursive Self-Improvement of Agent Harnesses
- Towards a Science of Scaling Agent Systems
- Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering
- HarnessDev: Can LLMs Create and Evolve Their Own Agent Harness?
- DarwinX: Evolving Agent Harnesses Through Natural Selection