HEELO Agent-Native Primitives: Last-Mile Harness Engineering for Real Tasks

Researchers from University of Illinois Urbana-Champaign, Georgia Tech and heelo.dev published The Last Mile to the Real World: Agent-Native Primitives in November 2026. Their claim is blunt: frontier models plus popular harnesses still fail when an agent must apply a resource it can already reach. They propose agent-native primitives — each resource ships with a resident LLM — and HEELO, a harness that composes, verifies and evolves those primitives per task.

If you have been following Terminal-Bench scores, the paper quotes familiar baselines: GPT-5.6 Sol with Codex at 37.3% on Terminal-Bench 4.0 and Claude Opus 5 with Claude Code at 51.8%. Their primitive families aim at that gap, not at leaderboard trivia.

TL;DR

The problem they name "last mile"

Classic agent stacks separate tool access from tool competence. An API wrapper exposes endpoints; the caller model must figure out parameters, error recovery and cross-tool choreography. The paper argues failures on real benchmarks cluster at the step from having a resource to using it correctly — the same framing as our FDE-Gym last-mile delivery benchmark and Terminal-Bench 2.0 explainer.

Agent-native primitives flip the split: the resource carries an interface LLM that applies it in context and talks to sibling primitives. Passive files become active participants with contracts, closer to design-by-contract modules than to dumb REST shims.

HEELO's three mechanisms

HEELO (Harness Engineering around Evolving Agent-Native Primitives for the Last Mile to Real-WOrld Tasks) builds a per-task harness from a library:

1. Library selection and composition — pick primitives via interfaces or self-assessed relevance; wire a task graph that routes messages and results.
2. Evidence-based execution — run rounds, verify against environment evidence, trace failures to implicated primitives, revise only those subtrees.
3. Validation and publishing — between tasks, admit new or improved primitives after tests, compilers or dev runs confirm them.

That third loop is why the paper stresses evolution — the library is meant to grow, not stay frozen like a static MCP manifest.

Eight primitive families

The authors instantiate eight families, each targeting a task shape:

• Tool Primitives for LLM tool use
• Code Primitives for repository work
• Math Primitives for formal proof
• Knowledge Primitives for retrieval-heavy tasks
• Agent Primitives for multi-agent coordination
• Dev-Primitives for software engineering
• Navigation Primitives for large information spaces
• Harness Primitives for agent harnesses themselves

Scale numbers in the abstract are large: 25,519 Tool Primitives (16,464 wrapping live APIs), 1,424 Code Primitives with bundled tests, 82 Math Primitives with compiling Lean artifacts. Those counts explain how composition could help — and how expensive the library is to reproduce.

HEELO targets the last mile between tool access and successful real-world task completion

MCP connections to heelo.dev expose agent-native primitives to Claude Code and Codex hosts

Benchmark interpretation for builders

Before you paste 55.5% into a slide, note what moved:

• Dev-Primitives target software engineering terminal tasks — the same broad genre Terminal-Bench popularized.
• Harness Primitives compare against a seed harness on Terminal-Bench 2.0 — a harness-on-harness upgrade, not a raw model swap.
• ToolBench gains isolate the tool layer; they do not automatically transfer to your internal APIs unless you build primitives with similar validation.

Independent teams should rerun a small slice of tasks with their own secrets and environments. Benchmark gains with author-built libraries often shrink on greenfield repos.

Dev-Primitives and Harness Primitives in the HEELO paper target Terminal-Bench-style software engineering tasks

heelo.dev and MCP

Beyond benchmarks, the group ships heelo.dev, marketed as tools for agents built for real work. The paper lists 46 real-world tasks across four end-to-end loops and reports that Claude Opus 5.5 with Claude Code and GPT-6.1 Sol with Codex each completed 9 tasks alone but 39 and 35 when connected through an MCP server, with lower time and cost per completion in their tables.

Official docs describe:

• Streamable HTTP MCP with bearer tokens (MCP page)
• REST tool invoke URLs per enabled tool (Developers page)

That is a concrete integration path if you already run Claude Code or Codex with MCP hosts — see our MCP guide for transport basics.

Treat heelo.dev as a productized slice of the research library, not as the full open-source drop. Read pricing, data handling and tool allowlists before pointing production agents at it.

How this relates to other "primitive" taxonomies

Amazon Quick's agentic primitives taxonomy organizes triggers, agents, capabilities and learned context for enterprise builders. HEELO is lower in the stack: resident LLMs on resources plus graph-shaped harnesses with verification loops.

Neither replaces the other. Enterprise catalogs tell you what to name glue; HEELO tells you how to package competence so glue stops being re-learned every task.

Risks and limits

• Library bias — Gains may reflect curated primitives tuned to benchmarks.
• Operational cost — Thousands of API-wrapping primitives imply maintenance when vendors change schemas.
• Security — Live API primitives widen blast radius; scope keys and use sandboxed hosts. For guardrail patterns, see AgentBeam and our agent sandbox comparison.
• Verification — Evidence-based revision helps, but environments can be gamed if checks are shallow.

Failure tracing: why the paper spends pages on evidence

A common failure mode in agent benchmarks is opaque retries — the harness loops until a timeout with no structured blame assignment. HEELO's second mechanism insists on environment evidence: tests, compiler output, filesystem state, or API responses that either match expectations or implicate specific primitives.

That design choice matters for engineering teams because it mirrors how senior developers debug pipelines: you do not rewrite the entire repo when one import fails; you patch the module that owned the broken edge. If HEELO's traces are as precise as the paper claims, partial reruns could cut cost per success even when headline accuracy gains are modest.

The risk is overfitting primitives to benchmark verifiers — if checks are narrow, composed graphs may look brilliant on Terminal-Bench yet brittle on messy customer VPCs. Treat published numbers as harness-aware, not environment-agnostic.

Primitive scale in one table

The Tool Primitive count is the headline shock. Operating that library in production is closer to running a managed integration platform than to shipping a single MCP JSON file. Teams without dedicated integration engineers should start with one family cloned to their stack, not the full catalog.

heelo.dev economics (as claimed)

The paper's 46-task suite reports not only higher completion counts but 1.9× and 2.3× less time and 1.55× lower cost per completed task when Claude Code and Codex attach through MCP. Those efficiency ratios are as important as accuracy for product teams billing by seat-month.

We did not audit heelo.dev invoices or token meters. If you pilot, log tokens, wall time, and human approvals with and without MCP for the same ticket queue. Compare medians, not best cases.

Mental model for MCP users

Today many MCP servers expose static tools — JSON schemas with deterministic handlers. HEELO's primitives add an LLM inside the tool boundary, turning each call into a mini-agent negotiation. That can reduce prompt complexity at the host model, but it can also hide failures inside primitive-local retries.

When wiring MCP, keep host-level policy: which primitives may spend money, which may write disk, and which require human confirmation. NIST, NSA and CISA agent guidance remains relevant even when micro-agents sit below the main model.

What to try this week

1. Read the arXiv abstract and introduction for definitions, not only Hugging Face summaries.

2. Pick one primitive family closest to your work (likely Dev or Tool) and sketch what a resident LLM would need to know.

3. If you use Claude Code, request a pilot MCP connection to heelo.dev on non-production tasks.

4. Re-run five Terminal-Bench-style tasks locally with and without structured tool wrappers to see if your bottleneck matches their "last mile" story.

5. Archive one failed run with primitive IDs enabled in logs so you can tell whether errors came from the host model, the wrapper, or the remote API.

What skeptics should check first

Independent readers should look for ablations that remove resident LLMs but keep schemas, and for library leakage between train and eval tasks. Positive signs include per-family breakdowns rather than a single blended score, and task lists that name concrete environment artifacts. Negative signs include undisclosed prompt templates or private APIs that cannot be re-authorized in third-party replication.

Related reading

• Terminal-Bench 2.0 benchmark guide
• FDE-Gym and the last mile of AI delivery
• Amazon Quick agent primitives taxonomy
• What is MCP?
• Loop engineering for coding agents
• Agent sandboxes compared

Benchmark figures are taken from the arXiv paper as of November 9, 2026; replicate before betting production architecture on them.