DSPy-style programming. RLM-powered agents. One compiled framework.

Build AI features and agents in your app.

Define the inputs and outputs. Improve results using examples and evaluations. Build agents that work through data and tools using code. One shared framework brings it all to TypeScript, Python, Java, C++, Go, and Rust.

Open-source AI library Validated outputs Cloud and local models Native in six languages

Build your first AI feature GitHub

Coding with AI? Install the Ax skills — give Claude Code, Cursor, and other coding assistants the Ax API guide for your language.

TypeScript classify.ts ax()

import { ai, ax } from "@ax-llm/ax";

const llm = ai({ name: "openai" });
const classify = ax(
  "review:string -> sentiment:class \"positive, negative, neutral\""
);

const result = await classify.forward(llm, {
  review: "This product is amazing!",
});

Python classify.py ax()

from axllm import ai, ax

llm = ai("openai")
classify = ax(
    'review:string -> sentiment:class "positive, negative, neutral"'
)

result = classify.forward(llm, {
    "review": "This product is amazing!"
})

Java Classify.java Ax.ax()

import dev.axllm.ax.*;
import java.util.*;

var llm = Ax.ai("openai", Map.of());
var classify = Ax.ax(
  "review:string -> sentiment:class \"positive, negative, neutral\""
);

var result = classify.forward(llm, Map.of(
  "review", "This product is amazing!"
));

C++ classify.cpp ax()

#include "axllm/axllm.hpp"

auto llm = axllm::ai("openai");
auto classify = axllm::ax(
  "review:string -> sentiment:class \"positive, negative, neutral\""
);

auto result = classify.forward(*llm, axllm::object({
  {"review", "This product is amazing!"}
}));

Go classify.go NewAx()

import ax "github.com/ax-llm/ax/packages/go"

llm := ax.NewAI("openai", nil)
classify := ax.NewAx(
  "review:string -> sentiment:class \"positive, negative, neutral\"",
  nil,
)

result, err := classify.Forward(ctx, llm, map[string]ax.Value{
  "review": "This product is amazing!",
}, nil)

Rust classify.rs ax()

use axllm::{ai, ax};
use serde_json::json;

let mut llm = ai("openai", json!({}))?;
let mut classify = ax(
  "review:string -> sentiment:class \"positive, negative, neutral\""
)?;

let result = classify.forward(&mut llm, json!({
  "review": "This product is amazing!"
}))?;

TypeScript audit.ts JS runtime session

import { agent, ai } from "@ax-llm/ax";

const llm = ai({ name: "google-gemini" });
const auditor = agent(
  "ledger:json[], question:string -> total:number, flagged:string[]",
  {
    contextFields: ["ledger"], // 250 rows stay in the runtime
    functions: [getVendor, getPolicy],
  }
);

const result = await auditor.forward(llm, {
  ledger, // never enters the prompt
  question: "Total PROJECT-X spend; flag txns over threshold",
});

Python audit.py Python host session

from axllm import agent, ai

llm = ai("google-gemini")
auditor = agent(
    "ledger:json[], question:string -> total:number, flagged:string[]",
    {
        "contextFields": ["ledger"],  # 250 rows stay in the runtime
        "functions": [get_vendor, get_policy],
    },
)

result = auditor.forward(llm, {
    "ledger": ledger,  # never enters the prompt
    "question": "Total PROJECT-X spend; flag txns over threshold",
})

Java Audit.java JVM host session

import dev.axllm.ax.*;
import java.util.*;

var llm = Ax.ai("google-gemini", Map.of());
var auditor = Ax.agent(
  "ledger:json[], question:string -> total:number, flagged:string[]",
  Map.of(
    "contextFields", List.of("ledger"),
    "functions", List.of(getVendor, getPolicy)
  )
);

var result = auditor.forward(llm, Map.of(
  "ledger", ledger,
  "question", "Total PROJECT-X spend; flag txns over threshold"
));

C++ audit.cpp C++ host session

#include "axllm/axllm.hpp"

auto llm = axllm::ai("google-gemini");
auto auditor = axllm::agent(
  "ledger:json[], question:string -> total:number, flagged:string[]",
  axllm::object({
    {"contextFields", axllm::array({"ledger"})},
    {"functions", axllm::array({get_vendor, get_policy})}
  })
);

auto result = auditor.forward(*llm, axllm::object({
  {"ledger", ledger},
  {"question", "Total PROJECT-X spend; flag txns over threshold"}
}));

Go audit.go Go host session

import ax "github.com/ax-llm/ax/packages/go"

llm := ax.NewAI("google-gemini", nil)
auditor := ax.NewAgent(
  "ledger:json[], question:string -> total:number, flagged:string[]",
  map[string]ax.Value{
    "contextFields": ax.Array("ledger"), // stays in the runtime
    "functions":     ax.Array(getVendor, getPolicy),
  },
)

result, err := auditor.Forward(ctx, llm, map[string]ax.Value{
  "ledger":   ledger, // never enters the prompt
  "question": "Total PROJECT-X spend; flag txns over threshold",
}, nil)

Rust audit.rs Rust host session

use axllm::{agent_with_options, ai};
use serde_json::json;

let mut llm = ai("google-gemini", json!({}))?;
let mut auditor = agent_with_options(
  "ledger:json[], question:string -> total:number, flagged:string[]",
  json!({ "contextFields": ["ledger"] }), // rows stay in the runtime
)?;

let result = auditor.forward(&mut llm, json!({
  "ledger": ledger, // never enters the prompt
  "question": "Total PROJECT-X spend; flag txns over threshold"
}))?;

Example result

{
  "sentiment": "positive"
}

Type-safe, validated, auto-retried on failure

{
  "sentiment": "positive"
}

Validated Python dicts from the same Ax signature

{
  "sentiment": "positive"
}

Java maps in, validated Ax fields out

{
  "sentiment": "positive"
}

Native values, shared validation semantics

{
  "sentiment": "positive"
}

Go values through the same provider boundary

{
  "sentiment": "positive"
}

Result-based errors, serde_json at Ax boundaries

{
  "total": 9161.10,
  "flagged": [
    "txn-2020", "txn-2054", "txn-2088",
    "txn-2105", "txn-2122", "txn-2156",
    "txn-2207", "txn-2224", "txn-2241"
  ]
}