Agent-Native by Design: A Programming Language for Agentic Applications

Jayanaka Dantanarayana, Savini Kashmira, Xiaoyu Ma, Malitha, Malitha Prabhashana, Lingjia Tang, Jason MarsarXiv 2026 · arXiv

TL;DR

Jac is a new "agent-native" programming language that unifies Large Language Model (LLM) calls, workflow logic, and application state into a single, cohesive syntax. By making the connection between model decisions and program execution explicit, Jac slashes boilerplate code by up to 8.7x and enables the compiler to automatically perform advanced optimizations like speculative execution.

What Problem Does This Paper Address?

Building "agentic" applications—where an LLM acts as a central brain making decisions and using tools—is currently a fragmented process. Developers typically use a mix of general-purpose code (like Python) and specialized SDKs or frameworks (like LangGraph or DSPy).

This creates three major headaches:

  1. Boilerplate Overload: Developers spend massive effort writing "glue code" to format prompts, parse JSON responses, and manually synchronize application state with framework internals.
  2. Maintenance Fragility: A simple change to a workflow step often requires coordinated updates across multiple, disconnected parts of the codebase.
  3. Optimization Blindness: Because the execution logic is split between the user's code and a framework's "black box," compilers cannot "see" the full workflow. This prevents automatic optimizations, leading to high latency as the system waits for sequential LLM calls.

Methods

The authors introduce Agent-Native Programming, realized in a new language called Jac (a superset of Python). Jac treats agentic abstractions as first-class citizens:

  • Meaning-Typed Model Operations (by llm()): Instead of manual prompting, you define a typed function and delegate its implementation to an LLM. The runtime automatically handles prompt construction, tool-calling loops, and output type conversion.
  • Object-Spatial Programming (OSP): Workflows are defined as graphs where nodes represent steps/data and edges represent possible transitions. An active agent is represented as a walker that carries state as it moves through the graph.
  • Model-Guided Routing (visit ... by llm()): This construct allows the LLM to choose the next node in the graph based on the current state and available paths.
Figure 1. An agentic workflow fragment expressed through three programming approaches. (a) Application code builds model inputs, updates state, and runs the selected steps. (b) Frameworks handle parts of model interaction and workflow execution, while application code connects their interfaces to workflow steps and state. (c) Jac expresses model operations, workflow structure and application state, and model-guided routing in one language, making their connections explicit to the compiler and runtime.

Because these elements are unified, the Jac compiler can perform Dependency and Effect Analysis. It understands which data an LLM call needs and what state it might change. This enables Speculative Execution: the runtime can predict the next likely step and start its LLM request early, overlapping it with the current routing decision to save time.

Datasets

The researchers evaluated Jac against five diverse benchmarks, comparing it to five baselines (OpenAI SDK, LangGraph, CrewAI, DSPy, and NOOA):

  • Meeting: Extracting and filing tasks from meeting transcripts.
  • Email: Drafting replies based on thread context.
  • RagGPT: A multi-specialist documentation assistant.
  • YTNavigator: A Q&A agent for YouTube content.
  • CodeAgent: An autonomous software repair agent evaluated on the SWE-bench dataset (360 pinned repository issues).

Key Insights and Ideas

  • Explicit Connections Enable Optimization: By baking the workflow graph directly into the language, the compiler gains "holistic visibility." It no longer sees an LLM call as an opaque side effect but as a predictable part of a data-flow graph.
  • The "Agent-for-Agent" Advantage: As we move toward AI agents writing code for other agents, language simplicity matters. The study found that AI coding assistants (like Claude Code) were significantly more efficient at writing Jac code than traditional SDK code.
  • Unified Semantics Reduce Errors: In traditional frameworks, you often have to declare possible next steps in three different places (the graph, the prompt, and the output schema). In Jac, one declaration handles all three, eliminating a major source of synchronization bugs.
Figure 3. CodeAgent implemented with (a) the OpenAI SDK and (b) LangChain with LangGraph. Purple marks model operations, blue marks agentic workflow structure and application state, and orange marks model-guided routing. Unshaded regions show supporting code, including request construction, response interpretation, and tool or phase invocation. The sidebars in (b) identify application code and uses of Lang- Graph interfaces.

Key Results

  • Code Reduction: Jac achieved a 1.8–8.7× reduction in AI-integration code compared to the OpenAI SDK.
  • Development Effort: When using AI coding agents to build applications, Jac builds consumed 48-51% fewer tokens than SDK builds.
  • Latency Savings: Compiler-driven speculative execution yielded median routing-decision latency savings of 29%–39% across three benchmarks.
  • Quality & Correctness: Jac maintained competitive task quality compared to expert-written baselines across multiple LLM families (GLM-5.3, Claude Sonnet 5, and Gemma 4 31B).

Limitations and Future Work

  • Side-Effect Assumptions: The current speculative execution model assumes that LLM requests don't have external side effects that are impossible to "undo" if a prediction is wrong.
  • Dependency on Metadata: The compiler's effectiveness relies on accurate "trusted declarations" of function effects. If these are missing or incorrect, optimizations might be skipped or become unsafe.
  • Future Directions: The authors suggest extending this model to more complex multi-agent systems and exploring further compiler-driven optimizations for distributed agentic services.

Summary updated

Abstract

Building agentic applications requires combining large language model (LLM) operations, workflow structure and application state, and model-guided routing. With SDKs and agent frameworks, developers connect these components through supporting code that prepares model inputs, propagates state, and dispatches model-selected steps. Workflow changes can require coordinated updates to this code, increasing development and testing effort. Splitting execution logic between application code and framework internals also limits compiler visibility into control flow and state dependencies, hindering automatic optimization. We introduce Agent-Native Programming, which unifies these three components with shared execution semantics. We realize this approach in Jac, a Python-superset language, through "by llm()" for typed model operations and tool use, Object-Spatial Programming for workflow structure and state, and "visit ... by llm()" for model-guided routing. The routing construct derives the model's choices from executable workflow steps and schedules the selected steps. This explicit connection between model decisions and program execution gives the compiler and runtime a common basis for dependency analysis and automatic optimization. Across five benchmarks and five baselines, Jac achieves a 1.8-8.7x reduction in AI-integration code relative to the OpenAI SDK, with competitive observed task quality and lower coding-agent development effort. Two case studies demonstrate speculative execution and service partitioning through configuration alone, using program analysis and runtime checks to preserve workflow behavior under stated conditions.
BibTeX
@misc{dantanarayana2026agent,
  author = {Jayanaka Dantanarayana and Savini Kashmira and Xiaoyu Ma and Malitha and Malitha Prabhashana and Lingjia Tang and Jason Mars},
  title = {{Agent-Native by Design: A Programming Language for Agentic Applications}},
  year = {2026},
  eprint = {2611.21298},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.21298},
}
Figure