GENT

A programming language for AI agents

Write agents in minutes, not hours. Type-safe. Parallel. Observable.

agent Researcher {
    systemPrompt: "You research topics thoroughly and cite sources."
    model: "gpt-4o-mini"
}

let findings = Researcher.userPrompt("quantum computing 2025").run()
println(findings)

Why GENT?

AI agent frameworks require endless boilerplate. GENT is a dedicated language that makes agents first-class citizens.

The Problem

# LangChain: 20+ lines before you even start
from langchain.agents import create_react_agent
from langchain.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain.tools import tool

llm = ChatOpenAI(model="gpt-4")
prompt = ChatPromptTemplate.from_messages([...])
# ... more setup ...

The Solution

// GENT: Just describe what you want
agent Helper {
    systemPrompt: "You help users with their questions."
    model: "gpt-4"
}

let answer = Helper.userPrompt("What is 2+2?").run()

Features

Agents

Declarative agent definitions with all configuration in one place:

agent DataAnalyst {
    systemPrompt: "You analyze data and provide insights."
    model: "gpt-4o-mini"
    maxSteps: 10
}

let insight = DataAnalyst.userPrompt("Analyze this: [1,2,3,4,5]").run()

Tools

Type-safe tool definitions that agents can use:

tool calculate(expression: string) -> number {
    // Tool implementation
    return eval(expression)
}

tool fetchWeather(city: string) -> string {
    return http_get("https://api.weather.com/{city}")
}

agent Assistant {
    systemPrompt: "You help with calculations and weather."
    use calculate, fetchWeather
    model: "gpt-4o-mini"
}

Parallel Execution

Run multiple agents concurrently with built-in timeout:

agent WebSearcher { systemPrompt: "Search the web." model: "gpt-4o-mini" }
agent NewsAnalyst { systemPrompt: "Analyze news." model: "gpt-4o-mini" }
agent AcademicSearcher { systemPrompt: "Find papers." model: "gpt-4o-mini" }

parallel research {
    agents: [
        WebSearcher.userPrompt("AI trends 2025"),
        NewsAnalyst.userPrompt("AI news today"),
        AcademicSearcher.userPrompt("latest AI papers")
    ]
    timeout: 30s
}

let results = research.run()  // Returns array of all results

Structured Output

Get typed responses from agents with compile-time validation:

struct Analysis {
    sentiment: string
    confidence: number
    keywords: string[]
}

agent Analyzer {
    systemPrompt: "Analyze text sentiment."
    model: "gpt-4o-mini"
    output: Analysis
}

let result = Analyzer.userPrompt("I love this product!").run()
// result.sentiment, result.confidence, result.keywords are typed

Agent Chaining

Compose agents naturally with variables:

agent Summarizer {
    systemPrompt: "Summarize in 2 sentences."
    model: "gpt-4o-mini"
}

agent Translator {
    systemPrompt: "Translate to French."
    model: "gpt-4o-mini"
}

let summary = Summarizer.userPrompt(longDocument).run()
let french = Translator.userPrompt(summary).run()

Error Handling

Graceful error handling with context:

try {
    let result = RiskyAgent.run()
    println("Success: {result}")
} catch error {
    println("Failed: {error}")
}

Installation

cargo install gent-lang

Or with Homebrew:

brew tap gent-lang/tap && brew install gent

Quick Start

1. Create a file hello.gnt:

agent Greeter {
    systemPrompt: "You are friendly and cheerful."
    model: "gpt-4o-mini"
}

let greeting = Greeter.userPrompt("Say hello!").run()
println(greeting)

2. Set your API key:

export OPENAI_API_KEY="your-key-here"

3. Run it:

gent hello.gnt

Examples

Run any example:

gent examples/hello.gnt

Run with mock LLM (for testing):

gent --mock examples/hello.gnt

Language Reference

Agent Declaration

agent Name {
    systemPrompt: "Instructions for the agent"
    model: "gpt-4o-mini"          // Required: LLM model
    maxSteps: 5                   // Optional: max tool calls
    output: StructName            // Optional: structured output type
    outputRetries: 3              // Optional: retry on parse failure
    use tool1, tool2              // Optional: available tools
}

Tool Declaration

tool name(param: type, ...) -> returnType {
    // Implementation
    return value
}

Types: string, number, boolean, array, object, any

Parallel Block

parallel name {
    agents: [Agent1.userPrompt("..."), Agent2.userPrompt("...")]
    timeout: 30s    // Required: 30s, 2m, 500ms
}

let results = name.run()  // Array of results

Struct Declaration

struct Name {
    field1: string
    field2: number
    field3: string[]
}

Control Flow

// Conditionals
if condition {
    // ...
}

// Loops
for item in items {
    // ...
}

while condition {
    // ...
}

// Error handling
try {
    // ...
} catch error {
    // ...
}

Design Philosophy

GENT follows these principles, in order of priority:

1. Agent-first — Agents are the primary abstraction, not an afterthought bolted onto a general-purpose language.

2. Fail fast — Catch errors at parse time, not in production. Type mismatches, missing fields, and invalid configurations are caught before your code runs.

3. Minimal boilerplate — If you're writing the same thing twice, the language should handle it. No decorators, no factory patterns, no dependency injection.

4. Observable by default — Tracing, logging, and debugging are built into the language, not libraries you have to configure.

5. One way to do things — Reduce cognitive load. There's one way to define an agent, one way to run it, one way to handle errors.

Status

GENT is in alpha. The language is functional but:

• Syntax may change between versions
• Some features are still being developed
• Not recommended for production use yet

Roadmap

• Agent declarations
• Tool definitions
• Structured output
• Parallel execution
• Error handling (try/catch)
• Control flow (if/for/while)
• Memory/context persistence
• Multi-model support
• Built-in observability
• Package system
• LSP for editor support

Development

Building

cargo build

Running Tests

cargo test

Running Examples

cargo run -- examples/hello.gnt
cargo run -- --mock examples/hello.gnt  # Mock LLM mode

Contributing

Contributions are welcome! Whether it's:

• Bug reports
• Feature requests
• Documentation improvements
• Code contributions

Please see CONTRIBUTING.md for guidelines.

License

MIT License. See LICENSE for details.

Acknowledgments

GENT draws inspiration from:

• Gleam — Friendly, type-safe language design
• Pkl — Configuration as code
• Dhall — Principled language design
• Jason — Agent-oriented programming research

Built with Rust, powered by pest parser.