Agentic AI

A new study of 1,200 agent trajectories reveals that coding agents frequently exhibit three cost-inefficient behaviors: subsumed retrieval, similar script generation, and test re-execution. These patterns impact up to 98% of tasks, driving unnecessary token consumption. The authors evaluate mitigation strategies like structure-aware retrieval and synthesized skills across 10,000 held-out trajectories to reduce this overhead.

• Subsumed retrieval, similar script generation, and test re-execution are the primary drivers of cost inefficiency.
• These wasteful behaviors affect between 79% and 98% of all coding agent tasks analyzed.
• Structure-aware retrieval and agent-synthesized skills offer viable paths to reduce token spend.
• Optimizing agent behavior is critical for scaling coding assistants without exponential cost growth.

Current LLM-as-a-judge evaluations often fail in production because they treat retrieved reference answers as literal targets, penalizing correct procedural actions that differ only in specific entity details like IDs or dates. This phenomenon, termed reference-instance divergence (RID), causes valid agent behaviors to be flagged as hallucinations. CARGO addresses this by treating references as procedural guides rather than exact templates, grounding judgments in the live instance's actual context.

• Solves reference-instance divergence where valid actions are penalized for differing identifiers.
• Shifts evaluation from literal matching to procedural correctness based on live context.
• Uses three-way claim status: supported, contradicted, or unverifiable.
• Only contradictions are penalized, reducing false positives in agentic AI monitoring.

This paper identifies a pattern termed 'LLM Parkinsonism,' where autonomous agents continue executing low-value actions even after their primary objective is satisfied. The authors argue this stems from a structural flaw where proposal generation, scope interpretation, and stopping authority are concentrated in a single self-conditioned loop. To address this, the work proposes an uncertainty-aware global executive control architecture designed to decouple these functions and enforce proper termination.

• Agents often fail to stop, producing redundant refinements or repairs to self-created complexity.
• The root cause is architectural: self-conditioned loops lack external executive oversight.
• Next-token prediction alone does not explain this persistence; control flow is key.
• A proposed global executive control architecture uses uncertainty awareness to manage scope.
• Decoupling proposal generation from stopping authority is critical for reliable autonomy.

Cartograph addresses the scalability bottleneck of the Model Context Protocol by replacing linear catalog traversal with progressive disclosure. It uses operator-attested capability cards signed via Ed25519 to ensure authenticity without relying on publisher rankings. The system employs a three-layer confusable-cluster analysis called Rift and a two-stage retrieval process to rank servers before individual tools, significantly reducing overhead.

• Shifts MCP discovery from O(n) to O(k) via progressive disclosure.
• Uses Ed25519 operator-attested cards for secure, decentralized tool descriptions.
• Rift mechanism clusters confusable tools using density and query-margin analysis.
• Two-stage retrieval ranks servers first, then tools, optimizing lookup paths.

A new architectural approach uses the Model Context Protocol to resolve conflicts between probabilistic LLM interactions and policy-driven data infrastructures. By implementing a mediation layer called Eunomia Agent, data space capabilities are translated into structured, schema-driven tools that AI agents can safely discover and invoke. This prototype validates end-to-end interaction while preserving strict governance constraints across organizational boundaries.

• MCP acts as a translator between LLMs and governed data spaces, ensuring policy compliance.
• Eunomia Agent exposes data capabilities as structured tools rather than raw text or APIs.
• Schema-driven discovery allows agents to invoke services without violating sovereignty rules.
• Prototype confirms end-to-end feasibility of mediated agent-data space interactions.

This paper introduces Learning What to Skip (LW2S), a method that optimizes multi-agent LLM workflows by selectively omitting redundant or harmful steps like verification or summarization. The approach treats component omission as a counterfactual credit assignment problem, using full-workflow logs and controlled skip interventions to learn action-specific safety models. By combining held-out calibration with domain-native guards, the controller decides whether to execute a step or skip it, preserving correct intermediate answers and saving computation.

• Reduces latency and token costs by skipping unnecessary workflow stages like verification.
• Uses counterfactual credit assignment to quantify the value of each component dynamically.
• Learns safety models from interventions, allowing the system to skip safely when appropriate.
• Prevents overwriting correct intermediate answers that might be lost by forced execution.
• Integrates with domain-native guards for robust decision-making in complex agent chains.

Spotify addresses the cold-start challenge in conversational recommendation by generating multi-turn synthetic data from single-turn prompts. This pipeline allows for systematic evaluation of agent planning before real user interactions are available. The system also employs a self-improvement loop to refine tool selection and sequencing over time.

• Synthetic data bridges the cold-start gap for conversational AI without waiting for real user logs.
• Multi-turn conversation generation enables robust planning evaluation prior to production launch.
• Self-improvement loops help optimize tool invocation strategies through variance-based contrastive learning.
• This approach accelerates deployment of complex intent-based recommendation systems.