Jac: A Python-Like Language Built for AI Agents, Explained

Jac is a new Python-like programming language, and its pitch is that most languages were written for human programmers while the thing doing the programming is increasingly an AI agent. University of Michigan professor Jason Mars presented Jac and its runtime, Jaseci, at the All Things Open conference in Raleigh this week, and The Register reported on the talk on October 23, 2026.

The headline claims are big: one language that "gobbles up" Python and TypeScript stacks, graph-shaped data, and an agent that built a better app in Jac than in LangGraph. Below we separate what is documented in the project's repository and site from what rests on a single conference demo, and show how you can try it with low risk.

TL;DR: Jac at a glance

Why a language for agents at all?

Mars's argument, as reported, is that agents are "drowning in polyglot complexity." Today an agent that ships a feature may touch Python on the backend, TypeScript on the frontend, a SQL database and several build tools. Each boundary costs tokens to translate and chances to make mistakes. In his words: "We're not using these tools anymore. We're using the agents, and the agents are using those tools. So I don't want new tools, but I want tools [for] my agents."

He anchored the point with a cost story. Bun's creator Jarred Sumner spent $165,000 in Anthropic tokens converting Bun's Zig code to Rust using a pre-release Mythos. Mars argued the expense came less from the difficulty of the job than from translating between two human-centered languages. We covered that rewrite in our Bun Zig-to-Rust post, and a related large-token rewrite in DHH's Rust rewrite experiment.

That framing is a talking point, not proof that a unified language would have cut the bill. A rewrite from Zig to Rust is a different problem from building a new app in one language. Treat the $165,000 figure as Mars's illustration, attributed by The Register to Sumner's reported spend.

What Jac actually is

The project site describes "one language, one compiler, the whole stack," with "AI, graphs, persistence, APIs, UIs, and cloud deployment as language features." The repository describes Jac as "the ultimate language for agents to build everything." According to The Register's account of the talk, the key design points are:

1. A Python-like surface. Familiar syntax for people and models trained on lots of Python.
2. Integrated Python and TypeScript runtimes and toolchains. Jac compiles to Python bytecode, JavaScript and native machine code, and can use any library from PyPI and npm.
3. LLVM integration. This brings Rust-style borrow checking and ownership semantics, and lets Jac import C and C++ libraries.
4. An "eject" function. Mars described reverse-compiling Jac code into TypeScript, Python or C to satisfy corporate compliance, which addresses lock-in worries.
5. Graph-first data. Data attributes are declared under node keywords and relationships as edges, instead of tables or class instances.

Java is the one currently missing language.

The graph model and walkers, in plain terms

The most unusual idea is how data is stored. In most apps you build database tables and tie them with foreign keys, or create objects from classes. In Jac the core data is a graph that can live in local memory, on disk or on a cloud server. Local logic can still use objects.

Why would that help an agent? Mars's argument is that agents burn tokens extracting data from databases, object blobs, JSON strings and Python objects. With a graph, the agent can dispatch a "walker" that traverses the structure and processes data on the go. Multiple walkers can go down different paths, producing natural parallelism.

The Register is candid that building a graph from all your data is more work than creating tables and foreign keys. The bet is that the upfront modeling pays off later. That is a design trade-off you should evaluate on your own data, not a given.

The LangGraph bake-off: what was shown

For the talk, Mars ran a comparison between Jac and LangGraph, an agent orchestration framework built on Python libraries. He asked an AI agent to use each platform to build a replica of Greptile, an AI code-review tool. According to The Register:

• With Jac, the agent "autonomously built a sophisticated multi-stage app that could call multiple tools in parallel."
• With LangGraph, the agent produced "a crude linear state machine that could not work in parallel."

Mars's takeaway: "The tools we provide the AI determine the quality of the output." That principle is sound and echoes our agent skills guide and our loop engineering guide, where harness design shapes results. But a single run with a single agent and a single model is an anecdote. We do not know which model drove it, how many attempts were made, how correctness was judged, or whether LangGraph was used idiomatically. The Register noted LangGraph's agent "was probably weighed down by all of the tools it had to use," which is speculation, not a finding.

How Jac differs from a framework like LangGraph

It helps to be precise about the category. LangGraph is a library you import into Python: you describe agent steps as a graph of states, and the surrounding application, database and frontend remain whatever you already use. Jac is a language and runtime, so the claim is broader. It wants the application code, the data model, persistence, the API layer and even the user interface to live in one place.

That difference cuts both ways. A library is easy to adopt in one corner of a codebase and easy to remove. A language asks for a bigger commitment, but it can enforce things a library cannot, such as how data is stored or how concurrent traversals run. When you read the bake-off result, keep in mind that the two tools were not solving the same-sized problem: one was asked to orchestrate, the other to be the whole stack.

What exists today

The Register lists current uses in smaller commercial services: the GraphClaw multi-agent platform, the Skooch scheduler and Tobu's personal memory platform. These are early and small. The project itself is old, though: the repository was created in October 2021 and was pushed to the day we checked, which suggests active development. 327 open issues is a normal number for a project of this size but means you will hit rough edges.

The article closes cautiously: "Whether developers and agents gravitate towards Jac's promise as a unified language remains to be seen."

What would make me adopt it, and what would make me wait

Reasons to try it

• MIT license and an eject path reduce lock-in risk.
• Access to PyPI and npm means you are not rebuilding the world.
• If your agents spend tokens shuttling data between systems, the graph model attacks a real cost. Our guide to token efficiency in Claude Code shows how much of the bill is overhead.

Reasons to wait

• No independent benchmark. The key comparison is one demo.
• A new language means new tooling, debugging and hiring. Models know Python far better than a young language, which can offset the "agent-native" advantage unless Jac is well represented in training data.
• Graph-first modeling is a bigger rewrite than swapping an orchestration library.
• No Java support.

How to try Jac this week

The lowest-risk path:

1. Read the project site and the GitHub repository for installation instructions for your version, since commands change between releases.
2. Pick one small, self-contained agent service, such as a scheduler or a memory store, not your core product.
3. Build the same service with your current stack and with Jac, using the same model and the same prompt.
4. Measure tokens, wall-clock time, tool-call parallelism and correctness on a fixed test set. Record failures.
5. Read the open issues for the features you depend on, especially deployment and persistence.

If you use the Model Context Protocol for tools, check how Jac services expose or consume it; our MCP explainer covers the standard.

What this means for what you build

The interesting idea in Jac is not the syntax; it is the question of whether agents do better with fewer languages and structured data. Even if you never use Jac, you can test the hypothesis: reduce the number of formats your agent has to translate between, expose data in one consistent shape, and measure the effect on tokens and errors. If a unified language wins in your benchmark, that is a stronger argument than any conference demo.

Related reading

• Bun's Zig-to-Rust AI rewrite and its token bill
• DHH's Rust rewrite experiment and 11M tokens
• What are agent skills? A complete guide
• Loop engineering for coding agents
• Claude Code token efficiency and prompt caching
• What is MCP? The Model Context Protocol guide

Repository figures were checked on October 26, 2026 and will change. Features described from the talk are as reported by The Register and may differ from the current release.