Simple enough to write by hand. Structured enough to generate from.

Semantic Guardrails for AI Coding.

AI coding is fast, but complex software needs semantic control. TeaQL turns prompt-generated models into stable, queryable APIs that give AI agents guardrails across business, system, edge, robotics, networking, and mobile software.

Not a low-code black box. Not a pile of generated source files. TeaQL keeps the model small, the API predictable, and the developer in control.

Get Started View on GitHub

Auditability-first AI coding

Generated code and tool calls must be traceable.

TeaQL gives AI-generated software semantic guardrails through domain models and query APIs, and runtime guardrails through context-bound execution. Every external effect passes through Context, is authorized by Policy, and is recorded by Audit.

Semantic guardrails: Domain Models + Query APIsRuntime guardrails: Context-bound executionGovernance trail: Policy authorization + Audit records

Code experience

Simple model. Predictable API. Normal service code.

TeaQL keeps the modeling surface small enough for humans to control, then compiles that model into stable APIs that developers and AI agents can use without editing generated infrastructure.

Model only the business structure

Describe objects, fields, relationships, and a few rules in a small model language that developers can read and maintain by hand.

<root>
  <merchant _name="Merchant" _module="sales" _module_key="sales"
    name="Acme Shop" external_id="ACME-001" />

  <order_status _name="Order Status" _module="sales" _module_key="sales"
    id="id()" name="string()" code="string()" merchant="merchant(context)"
    _constant="true" _identifier="code">
    <_value id="1" name="Paid" code="PAID" />
    <_value id="2" name="Cancelled" code="CANCELLED" />
  </order_status>

  <order _name="Order" _module="sales" _module_key="sales"
    code="SO-2026-0001" status="order_status()" total_amount="128.50"
    merchant="merchant(context)" />

  <order_line _name="Order Line" _module="sales" _module_key="sales"
    order="order()" sku="SKU-1001" quantity="2"
    merchant="merchant(context)" />
</root>

Generate predictable business APIs

The API shape follows the model: fields become typed filters and selections, relationships become graph loading methods, and runtime policy stays behind the boundary.

SmartList<Order> orders =
    Q.orders()
        .filterByMerchant(ctx.getMerchant())
        .whichStatus(OrderStatus.PAID)
        .selectMerchant()
        .selectOrderLineList(
            Q.orderLines().selectSku().selectQuantity())
        .orderByCreateTimeDescending()
        .executeForList(ctx);

Write normal application code

Developers and AI agents work against stable APIs instead of editing generated infrastructure or rediscovering persistence patterns.

public void approveOrder(CustomUserContext ctx, String orderId) {
    Order order = Q.orders()
        .filterById(orderId)
        .selectMerchant()
        .selectOrderLineList()
        .execute(ctx);

    order.approve(ctx.currentUser());
    order.save(ctx);
}

AI + Vibe Coding

Vibe code against stable business APIs.

TeaQL gives humans and AI coding agents the same generated API surface: readable Q queries, safe E expressions, Java service integration, and Rust runtime providers.

AI writes business logic, not persistence plumbing.TeaQL keeps the API surface stable.

Give AI a stable business API surface.

AI coding agents can generate feature code against Q APIs instead of reconstructing SQL, DTO mapping, relation loading, and pagination rules from scattered files.

Scattered SQL, mapper XML, DTO stitching

public PageResult<OrderCard> orderCards(
        CustomUserContext ctx, OrderSearch search) {
    return Q.orders()
        .filterByMerchant(ctx.getMerchant())
        .whichStatus(search.status())
        .selectCustomer(Q.customers().selectName())
        .selectLineItemList(
            Q.lineItems().selectSku().selectQuantity())
        .countLineItems()
        .orderByCreateTimeDescending()
        .paging(search.page(), search.pageSize())
        .executeForPage(ctx);
}

First Query AI guide

Human-controlled modeling

A model language small enough for developers to own.

TeaQL is not trying to replace developers with a heavy modeling platform. It gives teams a concise source of truth for repeated business structure, then keeps handwritten code close to business intent.

Simple enough to write by hand

TeaQL models describe business objects, fields, relationships, and rules without forcing teams into a heavyweight modeling platform.

Generated, not mysterious

The generated API surface is deterministic. Developers can inspect the model, predict the generated API, and review application code normally.

AI gets a stable boundary

AI agents write business workflows against typed TeaQL APIs instead of modifying generated file trees or inventing database access patterns.

Runtime & database support

One domain model. Multiple runtimes. Multiple databases.

TeaQL separates business APIs from storage execution. The same generated domain API can target PostgreSQL, MySQL, SQLite, in-memory tests, or embedded SQLite deployments.

Runtime / ProviderStatusBest For

Java TeaQL

StatusMature / Proven

Best ForEnterprise Java systems

Rust Core Runtime

Status~91% core runtime/kernel

Best ForAI-native and high-reliability apps

SQLx PostgreSQL Provider

Status~85%-90% usable path

Best ForProduction-grade backend services

SQLx MySQL Provider

StatusSupported provider crate

Best ForCommon enterprise database scenarios

SQLx SQLite Provider

Status~90% usable path

Best ForLocal-first apps, tests, lightweight services

rusqlite Provider

StatusAvailable

Best ForEmbedded, router, edge, multi-architecture devices

MemoryRepository

StatusAvailable

Best ForNo-database tests and simplified execution

What is TeaQL?

TeaQL is not just an ORM.

It is a generated business API layer built from your domain model. Model your domain, generate APIs, and run them across database and deployment choices.

Domain Model

Start from business objects, fields, relations, lists, and rules that define the application contract.

TeaQL Generator

Generate readable entities, Q APIs, selectors, filters, update helpers, and runtime-facing metadata.

Generated Q API

Compose type-safe business reads and writes through APIs that stay stable for humans and AI tools.

Why TeaQL

Stable business APIs for teams and AI agents.

Generated APIs make business intent explicit while runtime providers keep deployment choices flexible underneath.

AI-friendly APIs

Let AI call stable business APIs instead of guessing SQL, fields, relationships, and runtime behavior from scattered code.

Low cognitive load

Generated methods read close to business language, so reviews focus on intent instead of database plumbing.

Powerful business queries

Query, load associations, count, group, paginate, and aggregate in one expression without manual stitching.

Customizable runtime

Plug into transactions, cache, locks, logs, metrics, databases, edge devices, and agent memory.

Java and Rust

Proven in Java. Rebuilt in Rust.

TeaQL keeps the generated business API stable while allowing the runtime provider to change underneath. Java carries the enterprise productivity path; Rust brings a multi-database runtime for AI-native, edge-native, and embedded deployments.

TeaQL for Java

Replace scattered MyBatis code with generated business APIs. Reduce mapper XML, DTO stitching, association loading code, and one-off page query plumbing.

TeaQL for Rust

Run generated business APIs through a multi-database runtime with SQLx providers, rusqlite embedded deployments, Repository APIs, relation enhancement, graph writes, and transaction boundaries.

How it works

Stable generated APIs, switchable runtime providers.

TeaQL keeps the upper business contract readable and type-safe, while provider implementations handle the execution details.

Domain Model

Start from business objects, fields, relations, lists, and rules that define the application contract.

TeaQL Generator

Generate readable entities, Q APIs, selectors, filters, update helpers, and runtime-facing metadata.

Generated Q API

Compose type-safe business reads and writes through APIs that stay stable for humans and AI tools.

Runtime Provider

Run the same generated API against MySQL, PostgreSQL, SQLite, Memory, Edge, or Agent deployments.

Use cases

From enterprise systems to embedded business apps.

The Java path supports established business systems; the Rust runtime expands TeaQL into AI-native, agent memory, local-first, and edge deployments.

Enterprise business systemsERP / CRM / OMSIndustrial softwareAI-generated applicationsAgent memory runtimeEdge / embedded business apps

Supported databases

Keep the full database support list visible.

TeaQL targets practical production environments with explicit database support and model-driven runtime capabilities such as ensure schema and ensure index. Rust runtime support is currently marked for MySQL, PostgreSQL, and SQLite.