What happened
University of Michigan professor Jason Mars demonstrated Jac, a new programming language, and the Jaseci runtime at the All Things Open conference in Raleigh, North Carolina. The system is designed specifically for AI agents, integrating Python and TypeScript runtimes, compiling to multiple targets, and using graph-based data structures to optimize agent interactions with data.
University of Michigan professor Jason Mars presented Jac, a Python-like programming language, and the Jaseci runtime at the All Things Open conference in Raleigh, North Carolina. The core premise of the project is that traditional programming tools were designed for human developers and are ill-suited for the needs of AI agents, which currently struggle with 'polyglot complexity' across different language ecosystems.
Jac integrates both TypeScript and Python runtimes and toolchains, allowing it to compile to Python bytecode, JavaScript, and native machine code. It leverages the LLVM compiler to implement Rust-style borrow checking and ownership semantics, providing memory safety and performance benefits. The language can import C and C++ libraries and utilizes the full ecosystems of PyPI and npm. Mars noted that Java is not currently supported, stating, 'If you really need Java, Jac isn’t for Java.'
A key architectural of Jac is its use of graph-based data structures. Instead of traditional database tables or object-oriented classes, data attributes are defined under node keywords, and relationships are defined by edge connections. This allows AI agents to dispatch 'walkers' to traverse the data structure directly, reducing the need for agents to extract and process data from disparate sources like JSON strings or database blobs, which Mars argues consumes significant computational tokens.
During the conference, Mars conducted a comparative demonstration between Jac and LangGraph, a popular agent orchestration framework. He tasked an with building a replica of the AI code review tool Greptile. The agent using Jac autonomously built a sophisticated multi-stage application capable of parallel tool calls, whereas the agent using LangGraph produced a linear state machine that could not operate in parallel. Mars concluded that the quality of the agent's output is heavily determined by the tools and environment provided to it.
Source details: theregister.com ↗
Why it matters
The development addresses a specific inefficiency in current development: the high cost and complexity of managing multiple programming languages and data formats. By providing a unified environment where agents can directly traverse graph data structures and utilize integrated toolchains, Jac aims to reduce the token expenditure required for data extraction and code translation. This could lower operational costs for enterprises deploying complex multi-agent systems and improve the reliability of autonomous software tasks by minimizing the friction between agent logic and underlying infrastructure.
The primary value proposition of Jac is the reduction of 'polyglot complexity' in development. Mars cited an example where the creator of the Bun framework spent $165,000 in Anthropic tokens to convert Zig code to Rust, arguing that this cost was driven by the friction of translating between human-centered languages rather than the complexity of the task itself. Jac aims to eliminate this friction by providing a unified language that agents can use to interact with multiple underlying systems without extensive translation overhead.
By integrating graph computing directly into the language, Jac offers a more efficient way for agents to interact with data. Traditional approaches often require agents to fetch data, parse it, and then process it, a process that is token-intensive. Jac’s graph structure allows for direct traversal and processing, which Mars posits saves agents significant work and enables natural parallelism through multiple walkers traversing different paths of the graph.
The introduction of Jac represents a shift in programming language design from human-centric to agent-centric. While many current AI frameworks are built on top of existing languages like Python, Jac is designed from the ground up to accommodate the specific needs of agentic workflows, including memory safety via LLVM and seamless integration with existing package ecosystems. This could lead to more robust and cost-effective AI applications, particularly in enterprise environments where data fragmentation is a common challenge.
Interactive Mechanism: How It Actually Works
Explore the underlying technology behind this development interactively.
crm_get_transaction(id='4092').An agent must create a draft calendar event for Tuesday at 2 p.m. Which evidence would establish the requested result?
What to watch next
Monitor the adoption of Jac by commercial AI platforms and the availability of the Jaseci runtime for public use. Watch for independent benchmarks comparing Jac’s performance and cost-efficiency against existing frameworks like LangGraph, as well as any updates regarding the inclusion of additional language support, such as Java, which is currently excluded.
The current status of Jac and Jaseci is that they have been used in smaller commercial AI-related services, including the GraphClaw multi-agent platform, the Skooch scheduler, and Tobu’s personal memory platform. However, broader industry adoption and the availability of the tools for general public use remain to be seen. Developers should watch for official releases, documentation, and community adoption metrics.
Independent verification of the performance claims made by Mars is necessary. The bake-off against LangGraph was conducted by the creator of Jac, so neutral third-party benchmarks comparing cost, speed, and reliability across different agent tasks will be crucial for determining the practical impact of the language.
The exclusion of Java from Jac’s current support list is a notable limitation for enterprise environments where Java is prevalent. Future updates to the language or runtime that address this gap, or provide robust interoperability with Java ecosystems, will be important for its potential widespread adoption in corporate settings.