Agentic AI

This arXiv paper formalizes Spec-Driven Agentic Development (SDAD), a workflow where large language models ingest detailed Functional Requirement Documents and repository context to autonomously generate code. The process relies on disciplined upfront specification, machine-readable intent, and multi-agent verification before human sign-off. It positions specification quality as the primary fuel for autonomous software delivery.

• Frontier LLMs now handle massive context windows, enabling ingestion of full FRDs and repo history in one pass.
• SDAD shifts focus to upfront formalization and machine-readable specs to drive agentic synthesis.
• The workflow includes independent multi-agent verification steps requiring human sign-off for release.
• Specification quality becomes the critical determinant for successful autonomous implementation.

Agentic LLMs using the Model Context Protocol currently suffer high time-to-first-token due to quadratic prefill costs when re-encoding verbose tool schemas. Nexus solves this by decoupling routing from schema prefill, using an INT8 semantic lookaside buffer to select tools via retrieval instead. This approach generates arguments over a compressed textual signature rather than splicing key/value cache, resulting in a depth-independent workflow.

• Eliminates quadratic prefill cost by retrieving tools via INT8 semantic lookaside buffer instead of concatenating all schemas.
• Maintains ~89% routing accuracy even when scaling to 250 tools, where baseline approaches overflow the context window.
• Generates arguments over a compressed median 19-token signature, reducing sequence length and memory pressure.
• Achieves depth-independent performance, making it suitable for complex agentic workflows with deep tool use.

This arXiv survey consolidates research on large language model agents that operate primarily through terminal command execution. It proposes a seven-dimensional competence profile to evaluate how model, interface, harness, runtime, and environment jointly shape agent behavior. The work aims to establish clear workload boundaries and architectural connections for terminal-mediated systems.

• Surveys previously scattered terminal agent research across software engineering and tool use domains.
• Defines terminal agents by their dominant action-observation loop via command execution and text feedback.
• Introduces a seven-dimensional profile to assess terminal competence across multiple system layers.
• Highlights that realized agent behavior is a joint function of model, interface, harness, runtime, and environment.

A new arXiv paper introduces a method for heterogeneous language models to communicate by translating key-value caches directly, bypassing slow text decoding. It builds on prior work like C2C and LCF-X to remove the need for shared input contexts and eliminates the limitation where only the sharer model was compressed. This approach aims to streamline multi-agent workflows by allowing models to share encoded knowledge without discrete message passing.

• Bypasses autoregressive text decoding for faster multi-agent knowledge transfer.
• Enables communication between heterogeneous models without shared input contexts.
• Improves upon LCF-X by addressing previous compression and layer constraints.
• Represents a shift from discrete text exchange to latent cache translation.

Block has open-sourced Buzz, a self-hostable workspace built on the Nostr protocol that allows humans and AI agents to interact in shared rooms. The platform operates on a single-relay model where the URL defines the community scope, ensuring tenant-local state visibility. Licensed under Apache 2.0, it enables sovereign control over the communication infrastructure used for collaborative workflows.

• Buzz is a Nostr-based relay enabling real-time collaboration between humans and AI agents.
• Self-hostable with Apache 2.0 license, offering full data sovereignty and control.
• Single-relay architecture ensures URL-authoritative community boundaries and local state.
• Designed for shared workspaces where agents participate directly in human workflows.

Apache Maka is an incubating project providing a local-first AI agent workspace that operates through a single Runtime Host on your machine. It records model messages, tool calls, results, and permission decisions as an append-only log to ensure recoverable execution facts. The tool inspects projects and runs tools within a sandbox boundary to enhance security and traceability for local AI workflows.

• Local-first execution keeps data on your machine via one Runtime Host.
• Append-only logging captures all model interactions and tool outputs.
• Sandbox boundaries restrict tool execution scope for safety.
• Incubating status means the project is still stabilizing infrastructure.

PrimeAgentOrchestrator solves the empty context window problem for LLM coding agents by spawning instances pre-loaded with compiled memories. It queries a PostgreSQL entity-observation database and a Cloudflare Worker semantic search index in parallel, fusing the results via backend-specific strategies. The system injects the briefing into the agent's filesystem to leverage its configuration auto-read behavior, effectively preserving prior work knowledge.

• Eliminates session context loss by pre-loading relevant memories into new agent instances.
• Uses parallel retrieval from PostgreSQL and Cloudflare Workers for faster, fused context generation.
• Leverages filesystem injection to exploit host agent configuration auto-read capabilities.
• Demonstrates a practical pattern for persisting and reusing AI agent knowledge across sessions.