One-Line Summary

Agents get sturdier: a new verifier supplies continuous feedback while other papers tackle long-context memory, summarize long trajectories, and align high-level plans with executable robot skills.

Research Papers

LLM-as-a-Verifier raises agent reliability with continuous scoring

This paper turns a Large Language Model (LLM) into a verifier that scores how correct an AI’s answer is, producing continuous feedback instead of a single pass/fail or coarse rating—and it does this without additional training. By computing the expected score over token probabilities, the verifier offers fine-grained signals that better separate good from bad solutions. The authors frame verification itself as a new “scaling axis,” alongside pre-training, post-training, and test-time compute. ¹

Mechanically, the method turns token logits into a probabilistic, continuous score and scales along three levers: score granularity, repeated evaluation, and criteria decomposition. Higher scoring resolution improves calibration between positive and negative solutions, while repetition and decomposed criteria reduce variance and complexity. A cost-efficient ranking algorithm then selects the best candidate among many, using the verifier’s continuous scores. ¹

On benchmarks, it reports 86.5% on Terminal-Bench V2, 78.2% on SWE-Bench Verified, 87.4% on RoboRewardBench, and 73.3% on MedAgentBench. Beyond grading, these signals can act as a proxy for task progress; the team also ships a Claude Code extension so developers can monitor and improve their own agentic systems. ¹

For learning-from-feedback settings, the dense signal boosts sample efficiency for Reinforcement Learning (RL) methods including Soft Actor-Critic (SAC) and Group Relative Policy Optimization (GRPO) on robotics and mathematical reasoning tasks—positioning verification as a practical knob to tune, not just an afterthought. ¹

SeKV cuts long-context memory by summarizing on GPU and reconstructing on demand

SeKV reduces the memory cost of long-context inference by organizing history into semantic spans, keeping only lightweight summaries on the graphics processing unit (GPU) and storing detail on the central processing unit (CPU) for precise, on-demand reconstruction—without discarding information. It works with a frozen base model and adds under 0.05% trainable parameters. ²

Technically, SeKV treats the key-value (KV) cache as a resolution-adaptive, hierarchical memory: each span keeps a summary vector on GPU for fast routing and a low-rank SVD basis on CPU for token-level reconstruction when a query needs it. A trained “zoom-in” mechanism expands only the relevant spans during decoding. Across four benchmarks, SeKV improves over the strongest semantic compression baseline by 5.9% on average while reducing GPU memory by 53.3% at a 128K-token context. Code is available via the paper’s link. ²

CompactionRL teaches long-horizon agents to summarize their own history

CompactionRL trains long-horizon agentic LLMs to carry on beyond fixed context limits by learning to summarize past steps (context compaction) and continue under a compressed context. The approach jointly optimizes doing the task and writing useful summaries, aided by token-level loss normalization and cross-trajectory credit assignment. ³

On agentic coding, it lifts the first-try success rate (Pass@1): with GLM-4.5-Air (106B-A30B), it reaches 66.8% on SWE-bench Verified (+7.0 points) and 24.5% on Terminal-Bench 2.0 (+3.1). Built on GLM-4.7-Flash (30B-A3B), it reaches 56.0% (+5.5) and 20.2% (+6.8) respectively, and the method is used in the RL pipeline for training the open GLM-5.2 model (750B-A40B). Watch for how compaction interacts with other long-context tools like semantic memory and retrieval. ³

Cortex aligns high-level plans with low-level robot skills for long tasks

Cortex splits long robot tasks into 32 reusable skills and tightly aligns the high-level planner with the low-level controller so plans are executable. In this bidirectionally aligned framework, a vision-language model (VLM) plans subtasks that a vision-language-action (VLA) controller can actually execute, reducing the gap between “what to do” and “how to move.” ⁴

The team standardizes skills, injects tractability principles into data generation, and constructs training data from over 4,000 hours of open-source video plus 30 hours of simulation. Results show gains over monolithic baselines—3.1% on Libero-long and 4.1% on RoboTwin—and zero-shot completion of unseen long-horizon real tasks (e.g., multi-stage chemistry) by pairing the planner with a fine-tuned VLA. ⁴

Open Source & Repos

Omnigent: a plug-in harness to coordinate multiple AI agents

Omnigent is an open-source meta-harness that lets you orchestrate coding agents like Claude Code, Codex, Cursor, Pi, and your own—swap or combine them without rewrites, enforce policies and sandboxing, and collaborate in real time across devices. Version 0.4.0 turns harnesses into a true plug-in platform and adds an intelligent model router that picks for you. Licensed under Apache-2.0 and available on PyPI. ⁵

It targets teams building multi-agent workflows that need to experiment with different “brains” behind the same workflow. If you want a practical way to compare and contain various agents under one roof, Omnigent provides a consistent interface rather than one-off scripts. ⁵

Why It Matters

Today’s set hits three failure points for agent systems: knowing when an answer is correct (verification), remembering long histories (memory and context limits), and turning plans into physical action (robotics execution). A verifier that emits continuous scores, memory systems that compress without forgetting, and planners aligned to executable skills all reduce brittleness.

For non-developers, the takeaway is simple: agents become easier to trust. Better grading means safer automation, smarter memory means fewer frustrating resets, and aligned skills mean robots and software agents are more likely to finish the job they start.

This Week, Try It

1. Omnigent quickstart: Read the README and install from PyPI to orchestrate multiple coding agents under one interface. https://github.com/omnigent-ai/omnigent
2. Skim the LLM-as-a-Verifier paper: Focus on the figures explaining continuous scoring and the ranking algorithm. https://arxiv.org/abs/2607.05391v1