Welcome to TeaQL
TeaQL is harness engineering infrastructure for AI-assisted business application development. It connects an evaluated domain model, generated typed APIs, model-aware Assist, runtime governance, and executable verification.
Start with a small business model, generate a library and application in your chosen language, then prove a query and an audited save against a real database.
Choose Your Path
| What you want to do | Start here | What you should get |
|---|---|---|
| Build your first application with an AI coding agent | Getting Started | A reviewed model, generated workspace, and execution results |
| Use your preferred language | Language Guides | Setup, first verification, and customization for that runtime |
| Solve a specific development task | Cookbook | Focused recipes for queries, relations, mutations, and runtime behavior |
For the engineering rationale, read How the TeaQL Harness Works. For Skill lifetimes, progressive Assist and generated-code boundaries, start with How TeaQL Saves Agent Context. For adoption decisions, use Latest Versions and Conformance Status; package releases and retained execution evidence answer different questions.
Compare data-access choices
Start from the problem your application needs to solve:
- MyBatis alternatives for Java order pages: compare SQL/result mapping with a generated API, then follow a source-bound bounded-page example.
- Rust ORM partial loading and SQL NULL: distinguish absent values from unselected fields and repair a missing preload.
- Keyset vs offset pagination: compare SQL shapes, exact totals, sequential export and random page access.
- Vercel AI SDK database tools without raw SQL: define typed business capabilities and keep authorization on the server.
The Five Safeguards of AI Coding
TeaQL's approach to AI-assisted development does not rely on trusting an agent to infer the right persistence behavior from scattered code. It gives the agent a generated, typed, model-aware API surface and keeps runtime policy behind explicit boundaries.
- Constrained API surface. AI callers use generated, model-aware APIs instead of arbitrary storage logic.
- Mandatory intent metadata.
Queries require non-empty
commentandpurpose; mutations require an audit reason. These explain the business intent to reviewers and operators. - Less handwritten plumbing. A business operation can be expressed with fewer handwritten integration layers, reducing the amount of code humans must review.
- Runtime observability. Execution context, audit metadata, generated query structure, and logs help answer who ran what and why.
- Static typing and generated contracts. Static types in Java, Rust, Go, C# and TypeScript—and generated contracts in Python—catch or reject invalid call shapes before database execution.
TeaQL is not designed to make AI freer. It is designed to make AI work inside explicit model boundaries, typed APIs, auditable operations, and reviewable code.
Core Ideas
TeaQL keeps business API design separate from storage execution:
Domain Model
-> TeaQL Generator
-> Generated Q API
-> Runtime Provider
-> PostgreSQL / MySQL / SQLite / Meilisearch / Memory
The same domain model can generate APIs that read like business intent:
User userOrderInfo = Q.users()
.filterWithId(userId)
.countOrder()
.facetByOrderStatus("statusWithCount", Q.orderStatus().countOrders())
.selectOrderList(
Q.ordersWithId()
.selectOrderId()
.selectDate()
.offset(0, 10)
.selectLineItemList(Q.lineItemsWithId().selectImageURL().limit(3))
.countLineItems()
)
.comment("Query the user order summary")
.purpose("Render the authorized user order page")
.executeForOne(context);
One business page can be expressed as one fluent API instead of scattered SQL, XML, DTO mapping, and manual stitching.
What to Read Next
- Cookbook for task-oriented recipes.
- Rust database providers for provider selection.
- Working with Spring Boot for Java service structure.
- Start from a starter model when you are ready to build your own domain API.