TeaQL Agent Kit
A model-first coding harness that turns business intent into verified, typed application boundaries.
What does this agent do, and when should you use it?
TeaQL Agent Kit is a model-mediated workflow for agentic software development. It asks an agent to save business intent as a KSML domain model, evaluate that model deterministically, and repair reported issues before implementation begins. The TeaQL Generation Service can turn a validated model into Java or Rust typed domain libraries and separate editable application workspaces. The workflow also supplies model-aware assistance and treats compilation, tests, runtime checks, and audit results as completion evidence. It is best suited to teams prepared to adopt TeaQL's modeling, generation, and runtime-governance approach rather than a general-purpose coding assistant.
Its published Skill is named build-teaql-app. The workflow creates and saves a KSML XML model for business objects, fields, constants, relationships, modules, and storage; evaluates it; and uses the returned Errors, Warnings, Suggestions, and repair guidance to revise the model. After validation, the TeaQL Generation Service generates typed entities, relation metadata, queries, null-safe expressions, graph persistence, checker and behavior hooks, repository registration, documentation, and a Java or Rust application workspace. Application code works through the generated surface, such as Rust's Q::merchants() with purpose(), comment(), and execute_for_list(&ctx). The final stage verifies implementation with compilation, tests, runtime results, and policy checks.
- A Java team using domain-driven design that wants a reviewable domain model before regenerable typed application contracts are produced.
- A Rust team building data-heavy software that wants to use typed Q and E APIs for queries and relation-graph persistence.
- An engineering organization that requires coding agents to submit a saved KSML model, evaluate it, and regenerate when the domain contract changes.
- A business-data application that needs UserContext, query purpose and comments, and write audit descriptions to travel with execution.
- A team that wants human reviewers to inspect a model asynchronously while the agent continues generation, implementation, testing, and repair.
What are this agent's strengths and limitations?
- KSML is a saved, inspectable intermediate representation, providing a concrete review point between requirements and code.
- Deterministic model evaluation returns errors, warnings, suggestions, and current repair guidance instead of relying on an agent to retain a large rule catalog.
- Generated Java and Rust domain libraries are separated from editable application workspaces, allowing the model-derived contract to be regenerated.
- Runtime APIs carry identity, read purpose and comments, write audits, and explicitly granted external capabilities.
- Adoption requires teams to learn and maintain KSML models and to follow a model-before-implementation development sequence.
- The fullest documented output depends on the TeaQL Generation Service; the open-source teaql-forge-rs implementation is explicitly described as not claiming full feature parity.
- This repository publishes the Skill rather than runnable applications; Java and Rust examples live in separate repositories with independently evolving toolchains and releases.
- The supplied documentation does not describe offline or self-hosted deployment for the evaluator or Generation Service, nor does it specify authentication, pricing, or service guarantees.
How do you install or deploy this agent?
The documented installation command is: npx skills add teaql/teaql-agent-kit --skill build-teaql-app. It requires npx, network access, and a filesystem where models and generated workspaces can be saved. The documentation does not state whether an account, API key, or other credential is required.
How do you use this agent?
After installation, ask a coding agent with a prompt such as: Use $build-teaql-app to first draft and save a complete KSML model, then evaluate and repair it before generating a runnable TeaQL application: [your business requirement]. The prescribed order is to save a complete model, evaluate and repair it, generate the application, implement within the generated contract, verify the result, and report evidence. The Generation Service's /latest/ endpoint presents the current demo, and the documentation notes that it may evolve.
How does this agent compare with similar options?
Compared with a conventional “requirement → agent → code → test → repair” coding-agent loop, TeaQL inserts an inspectable KSML model, deterministic evaluation, and a generated typed contract before implementation. The trade-off is stronger process discipline and reliance on the TeaQL model-and-generation ecosystem.