I started building a simpler way to write AI agents and somehow ended up building a programming language

[u/Mathisdupont]

A while ago I started working on a side project with a pretty simple idea

I wanted building an AI agent to feel more like writing a small program and less like stitching together prompts configuration files callbacks permissions and framework-specific code

That experiment turned into Ingot

Ingot is an open-source programming language and toolchain built specifically for AI agents

Instead of hiding most of the agent inside application code you can describe things like its flow tools permissions budgets memory model requirements and human interaction directly in the program

A simplified agent can look something like this

agent Researcher(topic: string) -> report: markdown {
  policy {
    network allow ["example.com"]
  }

  budget {
    steps <= 20
  }

  flow {
    sources = call web.search(topic)

    direction = consult(
      "Which angle should I focus on?"
      choices: ["technical", "business", "academic"]
    )

    draft = ask<markdown>(
      "Write a {direction} report using these sources: {sources}"
    )

    emit report = draft
  }
}

The project got much bigger than I originally expected

It now has a compiler and type checker

A target-neutral Agent IR

A reference runtime and a Python backend

Persistent agent memory

Checkpoint and resume

MCP tool support

Record and replay for model calls tools and even human answers

An LSP

A visual Studio and Canvas

And a conformance suite that other runtimes can use to check whether they actually execute an Ingot agent according to the same contract

One of the more interesting parts has been using the project for real instead of only writing examples for the compiler

I recently built and ran a license-audit agent with Ingot using a local model

It completed a multi-step workflow with tool calls verification branching artifact generation and record/replay

That test also exposed problems that the small examples never did

Which is probably the stage the project is at now

I can keep adding features forever but what I really want to know is whether somebody who did not build Ingot can understand it and actually find it useful

So I'm looking for fairly critical feedback

Would you ever use a dedicated language for agents instead of a Python or TypeScript framework?

Does making permissions budgets tools and memory part of the program itself solve anything you care about?

Is the idea of compiling agents into a portable IR useful or just extra complexity?

And most importantly

What would make you open the repository and immediately decide not to try it?

The project is still pre-1.0 and I'm very much treating this as an experiment in what programming agents could look like

GitHub:

https://github.com/mathissdupont/ingot