TAFI
The AI co-builder for TechAppForce
Describe an app in plain English. A multi-agent pipeline drafts the requirements, designs the data model, plans the build as a dependency graph, and registers every entity, screen, query and workflow on the live low-code platform, pausing for your approval at four gates and verifying every output so nothing is fabricated. A certified run built a 27-step leave-management app in ~12 minutes.
“Build a leave-management app, employees request time off, a manager approves or rejects, and HR sees a balance per person.”
- 4 entities · LeaveRequest, Employee, Balance, Policy
- 5 screens · request, approve, balance, admin, list
- 2 workflows · approval + balance-decrement
- 27 build steps · 96 platform writes
Values shown are the canonical figures from the certified 27-step run, 96 platform writes, QA 100, 3 consecutive clean runs.
Not a mockup.
The shipping app, running.
The same pipeline inside the live TechAppForce builder, replayed in the order a build actually runs: describe an app in plain English, watch TAFI plan and build it step by step, and find every build tracked in one workspace.
One description in.
A working application out.
Three milestones, each gated by a human approval. The whole pipeline is wrapped by a typed MCP gateway and grounded by a cited knowledge base, so nothing reaches the platform unverified. This is the pattern behind our agentic pipelines practice.
Expert developer time,
measured in hours.
Building an application on TechAppForce takes specialist developer time measured in hours. A developer manually coordinates dozens of API writes across six subsystems in exact dependency order, with no tolerance for sequencing errors.
Mistakes are silent, phantom IDs and broken field references surface only at QA, forcing rework that compounds the original overhead. The cognitive load resists delegation: it needs platform expertise that documentation can't transfer, and that expertise becomes the bottleneck as usage grows.
A developer hand-coordinates API writes across 6 subsystems. Hours per app. Phantom IDs surface at QA. Platform expertise is the bottleneck.
Type a plain-English description. TAFI generates the full application, 96 API calls, correct dependency order, propagation verified. No manual steps.
Six parts, each killing
a class of failure.
Every component exists to eliminate a specific failure the previous approach hit at scale, not for novelty.
Multi-Agent Pipeline (CrewAI)
A planner decomposes the request into a dependency graph; an executor walks it with level-based parallelism and per-step isolation; specialist worker crews run each step. Failures trigger bounded replanning, not a crash.
15 KB-Driven Skills
One specialist "designer" skill per artifact class, each a YAML manifest with a manager+reviewer dual-agent pattern and an output contract. Add or change a skill by editing a doc, not code.
MCP Integration Gateway
All platform writes route through the FastMCP gateway: reads over REST, writes over RabbitMQ/MassTransit. An idempotent lookup→normalize→publish→poll composer guarantees exactly-once registration, re-runs never duplicate.
Contract Verifier, 8 Rules
Hard-rejects fabricated UUIDs and "claimed success with no tool call," and cross-checks each agent's claimed calls against the gateway's real count. The fabricated-data class is killed structurally, not prompted away.
Knowledge Base, Mem0 + BM25 + Graph
Vector retrieval raced against a BM25 keyword fallback, plus deterministic link-graph expansion. Every enum value is cited from C# source at file:line, a grounded, zero-hallucination reference for every field decision.
Provider-Agnostic Routing (LiteLLM)
Five model tiers with fallback chains, reasoning-tier escalation by entity count, a hard $5/session budget cap and a dry-run mode. No vendor lock-in; cost is bounded before a build starts.
Six promises most code-
generation can't make.
A model that writes plausible code can't tell you it didn't invent an enum, won't duplicate a record on retry, or will refuse to ship unverified. TAFI can, each guarantee is enforced by structure, not by a prompt.
Zero-hallucination enums
Field types, query operators, blueprint statuses and screen types are not free-text the model can invent, they are read from the Scopes/ layer, 10 code-verified directories where every value is cited from C# source.
→ Cited from source · file:line · 10 scope dirs
Idempotent platform writes
Every registration runs lookup → normalize → publish → poll, then waits until the write is confirmed visible on the TAF REST API. Re-running a build repairs state; it never duplicates a record.
→ Propagation poll 20×5s · safe to re-run
Strict dependency ordering
The planner emits a DAG; the executor walks it level by level. A skill never references an ID an earlier stage has not yet committed, so phantom IDs cannot enter the graph in the first place.
→ 8 dependency stages · level-based walk
Eval-gated shipping
Nothing ships on a green eval alone. A build must pass the deterministic harness (Score = 100 − Σ penalties) and then clear three consecutive clean runs before it is certified.
→ QA 100 · 3 clean runs required
Contract-verified output
The eval scored Equipment Tracker 100 yet platform verification still caught five failure classes, dead-lettered queries, empty screen JSON, consumer-less bus commands, missing nav columns, no audit trail. All five are now checked against live state.
→ 5 failure classes the score was blind to
Platform-agnostic by construction
Zero TAF-specific strings live in the production runtime (E13.F6). Supporting a new low-code platform is a YAML config plus KB documents, not a new code path through the pipeline.
→ New platform = YAML + KB · 0 new code
The reason an enterprise can trust an autonomous builder: every output is gated, checked, and idempotent, not "trust the LLM."
Requirements · Blueprint · Implementation · Release. Approve, request a change in plain English, or rewind, never a black box.
Eight contract rules reject fabrication; agent claims are reconciled against real gateway calls. "Done" means provably done.
Lookup-before-create plus poll-for-visibility means a re-run repairs, never duplicates. Exactly-once registration on a live platform.
A passing eval is
not the finish line.
Most teams ship when the eval goes green. We don't. Every build clears two independent gates, and only ships when both agree.
On TAFI, the eval returned QA 100, every story passed. Gate 2 still caught five issues the eval was blind to, all invisible to a score:
- Queries dead-lettered in the message bus
- Screen-container JSON rendering empty
- Workflow bus commands with no TAF consumer registered
- Navigation records missing required columns
- No audit trail on artifact generation
All five fixed, then three consecutive clean runs. The score only became trustworthy once it matched verified platform state, which is the discipline behind every eval number Agentix publishes. We run the same eval / red-team / regression discipline on shipped AI as AI Assurance, and document the method in how we work.
15 skills, resolved into
8 dependency stages.
Each skill is one specialist designer, a YAML manifest with a manager+reviewer dual-agent pattern and an output contract. The planner sorts them into a DAG so every stage runs only once its inputs exist. Two meta-skills sit outside the enum: they run the pipeline, not a step in it.
Analyst
analyst Plain-English prompt → RequirementsDoc. No platform writes, pure intake.
Blueprint Architect
blueprint_architect Build order, entity relationships, has_workflow flags. Artifact-only; the spine every later stage reads.
Entities
blueprint_registrardb_designer MSSQL DDL + AppObject registration; workflow blueprint entities registered first.
Queries
query_designer Data Source Queries built against the AppObjects registered one stage up.
Screens & Components
component_designerscreen_designerscreen_validator form.io component selection, schema + DSQ binding, then a read-only JSON integrity pass.
Parallel Execution
extension_designertheme_designerworkflow_designer Three independent skills run concurrently, no inter-dependency inside the stage.
Navigation
navigation_designer Modules, categories and menu items wired to the registered screens.
Routing
routing_designer Site map + routing config, the last layer before the app is navigable.
What changed,
measured.
Not projections, the measured delta between the manual baseline and the shipped system.
to build a 27-step leave-management app · certified run, 96 platform writes, QA 100
~1,615 commits.
Five repositories.
Sustained, parallel delivery, not a vanity number. The 1,428 commits tracked across the five repos below were authored by Sagar Maheta, Vaishali Kochar, Mohit Jagatiya and Bhavik Thakkar, with AI collaborator Sammy on the knowledge base.
-
taf_tafiCore pipeline engine 951 -
superprojectRoot ecosystem coordinator 116 -
taf_knowledgebase21 Pattern docs · Scopes/ · surface index 162 -
taf_mcpMCP gateway · 11 tools 127 -
taf_tafifrontendAngular 19 · 32 components 72
Open-source.
Self-hosted. Owned.
Every layer owned by the client from day one, no vendor lock-in, no ongoing platform fees.
Want a system like
TAFI for your platform?
Tell us what you're building. We'll tell you how we'd architect it, what it would take, and the eval it would have to pass before it ships.