The Proof: 4 Years → 1 Weekend → 5 Minutes
A US state agency. Two developers. Four years of procedural code. Never shipped.
Rebuilt with declarative rules over a weekend.
Then AI reduced that to five minutes from a business prompt.
See the Allocation Case Study.
Full API, governed from the first commit
Business logic declared once, enforced on every path
Auditable by design — requirement → rule → execution log
AI readable — rules, not generated spaghetti
The same prompt to AI alone
tells a different story...
Allocate Charges to Departments,
and to their General Ledger Accounts
See the Reference Implementation
AI alone can create a system from the same business prompt.
The demo looks great. But, when you analyze it, it breaks down.
Four structural failures that prompt engineering cannot fix:
Correct Dependency Ordering — Complex business logic has transitive dependencies AI cannot reliably infer. In our A/B test, AI-generated procedural code had silent bugs — visible in the actual generated code as comments labeled "CRITICAL BUG FIX — added after prompting." When asked to explain, the AI diagnosed itself: "Business logic is not a coding problem. It's a dependency graph problem. Transitive dependencies cannot be reliably inferred from procedural control flow."
Review-ability — Translated into rules, logic retains the original intent — auditable, reviewable, traceable to the requirement. Translated into procedural code, it explodes 40x. Too much to review, and the intent is buried.
Iteration At Scale — Procedural code bakes dependencies into the code itself. Every small iteration requires re-generating the whole. At hundreds of rules, hallucinations and missed dependencies are inevitable.
Logic Bypass — Logic in code paths can be bypassed. A new agent, a new endpoint, a new developer next month — none inherit the rules, because there are no rules to inherit. There is no architectural control point.
This is not a prompt problem. It is a structural limitation.
Allocate Charges to Departments,
and to their General Ledger Accounts
AI alone also creates a system. It runs.
But is demo-ware -- serious bugs.
See the Allocation Case Study.
Context Engineering directs AI to generate Data Rules — not procedural code. Without it, AI pattern-matches to FrankenCode. With it, intent becomes declarations.
Data Rules distill path-dependent logic into path-independent rules on data. See them below— Rule.constraint, Rule.sum. No missed paths. Every path inherits them automatically.
The Commit Listener hooks into the ORM commit. Every transaction — API, agent, workflow — passes through one control point. Nothing bypasses it.
The Rule Engine computes dependency order from the Data Rules at startup — deterministically. No pattern-matching, no subtle ordering bugs.
Rules are the intent, made executable —
infrastructure that governs by architecture, not discipline.
Executable Requirements — The Gherkin your team already writes becomes the governed starting point. Rules, tests, and audit trail from one requirements file. [Learn more →]
5 rules replace 200+ lines of procedural code — 40X more concise.
Readable — the rule is the requirement. Business and IT read the same artifact. No translation layer, no gap between specification and implementation.
Auditable — every transaction traces to the rule that governed it. Rules fire automatically on every path, without exception — so the audit trail is complete by construction. Requirement → rule → execution log. Compliance can prove governance, not just assert it.
Maintainable — change the business logic, change the rule. Self-ordering - no archaeology, no missed paths, no ripple analysis, no regression surprises.
Familiar tools — Python, your IDE, your debugger, your source control, deploy as container. Rules live in the repo like everything else. No proprietary lock-in, no new stack to learn.
Enduring — new agents, new endpoints, new developers. All inherit the same rules automatically. Governance doesn't erode as the system grows.
Optimized — Non-RETE engine, purpose-built for transactional performance at commit
When the rule is the requirement, governance becomes a strategic asset — not a discipline you enforce, but an architecture you deploy.
Requirements describe intent. Code approximates it. The gap is where projects fail and governance erodes.
Declarative Data Rules close that gap — enforced by a purpose-built Rules Engine — for specific reasons procedural code cannot match:
Correct Dependency Ordering — Complex business logic has transitive dependencies are resolved by the rules engine, deterministically.
Review-ability — Translated into rules, logic retains the original intent — auditable, reviewable, traceable to the requirement.
Iteration At Scale — New rules can be introduced easily. Dependencies are computed at runtime by the rules engine - no hallucinations.
Logic Bypass — Logic always executes at commit time.
The deck walks this through end-to-end using a real integration example.
→ Click to see the architecture at work.
2 years of failed procedural code rebuilt with declarative rules in a weekend. Then 5 minutes with AI.
A Canadian customs regulation compiled directly into a governed, running system. Regulatory text as the input. No developer interpretation.
Governance by architecture identified compliance exposure in existing production code that governance by discipline had missed - an 8 figure exposure.
The use cases below aren't separate products or bolted-on features — they're consequences of one decision: put the rules on the data, not the path. Build the governed backend once, and the rest follows.
AI can reason at runtime, its outputs governed deterministically before commit. The API is MCP-discoverable, so agents can use it. The logic holds regardless of source, so a Vibe UI sits safely on top. Every transaction passes one control point, so the audit trail comes free.
That's the test of an architecture — not how much you build, but how much you get for free.
These are delivered, running samples
For example, here is an AI Rule:
Use AI to Set Item field unit_price by finding the optimal Product Supplier based on cost, lead time, and world conditions
This logic (from GenAI-Logic Context Engineering):
Calls LLM with list of suppliers for a product
LLM chooses optimal
That compute the price
Which is then used - and governed - by other rules
For example, if the Suez Canal is blocked, choose higher-priced suppliers other than Cairo
AI can make mistakes, so governance is mandatory:
Results subjected to deterministic logic, automatically
Results audited to database (see slides
Create Backend directly from existing database
Run created system:
• JSON:API, MCP Discovery
• Admin UI
• ORM Configuration
Declare business logic in NL or Python
Declare underlying services (e.g., send email, honoring opt-out)
Build Apps for Business Users to make MCP requests (send email to overdue orders)
MCP requests are governed (eg, email opt-out)
Business Users Enabled
Use an App to make NL requests:
Read / update the database (e.g. find customers)
Send email
genai-logic create --project_name=basic_demo --db_url=sqlite:///samples/dbs/basic_demo.sqlite
cd basic_demo
sh run.sh
To verify, paste this into your AI Assistant:
Using mcp discovery, list the customers with a positive balance.
See here for details on how to use Natural Language to:
Create multi-table logic for governance
Create an audited email service
Create MCP client (shown below)
Traditional EAI platforms handle routing and transformation. The hard part — business logic — remains "your code goes here".
GenAI-Logic is different:
Same rules, every path — the Data Rules that govern API transactions govern message consumers automatically. No additional wiring.
Same transaction — inbound messages trigger your declarative derivations, constraints, and multi-table updates at commit. Not a service call. Not a separate layer. The logic and the persistence are one.
Governed Capture — the raw message commits first, guaranteed. Parse failures are recoverable, never lost.
AI-driven mapping — provide a message format, AI maps fields automatically. Exceptions flagged. Unresolvable fields block server start.
One prompt each — subscribe to a message broker, create a custom B2B API.
Create Integrations With a Prompt (scroll to see)
Rules are enforced by the runtime at transaction commit — Apps, APIs, Messages
Executable Requirements →
GenAI-Logic creates backends instantly, for data access with governance
Vibe your Apps with your favorite Vibe tools using the standard JSON:API
The API encapsulates the logic, so it's inherited - automatically.
This simplifies Vibe:
App Dev is not delayed waiting for APIs.
Logic is factored out of each app - where it never should have been in the first place. Sharing across apps - and services - is automatic.
Once logic is factored out of the UI, logic and app dev can proceed in parallel.
Logic changes are inherited in all existing apps, automatically.
AI scaffolds full applications that developers can refine using familiar tools, backed by the deterministic rules engine.
Install GenAI-Logic and run any use case above as a 10-minute, start-from-scratch evaluation:
one command → a few Copilot prompts → running system (API + Admin UI + governed rules).
Your AI assistant guides you through creation, rule authoring, and debugging, and can answer evaluator questions like:
“Is this a black box?” “Where do rules execute?” “How do I extend logic?”
Install and Start - Choose a Demo
With declarative business logic, creating a system can finally match the way we think about it.
With backend logic governed and deterministic, WebGenAI can generate UI, API, data, and logic from natural language.
Business users prototype in WebGenAI.
IT receives a standard, extensible backend — not a low-code black box.
AI scaffolds full React applications that developers can refine using familiar tools, powered by a deterministic rules engine.
GenAI Logic allows us to further accelerate the development of innovative software solutions that respond to the growing need for digitalization and process automation. Ontimize Web, our low-code web application framework, allows developers to declaratively implement powerful user interfaces for complex business applications. By integrating Ontimize Web with GenAI Logic, we automatically obtain a robust rules-based backend that fully supports the needs of our frontend and a fully documented API.
Furthermore, the generative capabilities of GenAI Logic allow us to automatically generate 90% of the application from a prompt. That’s really impressive! Most importantly, it means that our developers no longer have to manually declare hundreds of user screens, with their corresponding CRUDs, business logic and API endpoints. They can now focus on understanding the business requirements and designing a user experience that customers will love.
Rowbot is a new breed of data management platform that enables a true Data Mesh architecture. It allows non-technical business users to integrate data from multiple disparate databases and create a unified view of activity across the organization.
We output a unified dataset and pass that to GenAI Logic. In 2 minutes we have a fully functional application, allowing an analyst to see customer activity across all participating systems.
Then we can incrementally introduce business rules. These rules can range from alerts based on the data to propensity flags for marketing. Users cannot believe how quickly a unified view of the data can be presented and then enriched by the GenAI Logic rules engine.
I can’t say enough about ApiLogicServer. I’ve been using ALS for a number of years now having successfully delivered several solutions that started as an ALS app. ALS provides us an advantage when not only starting new projects, but also when gathering requirements. Including ALS as a tool within the SDLC has been instrumental in several migration projects as well. This is our bread and butter, and we use ALS more than any other framework in our projects.
I am excited to see the evolution of ALS into GenAI Logic using AI as the nexus for new project implementations. Thank you Val, Tyler and Thomas for a promising and powerful solution. ALS's iterative capabilities are especially helpful; driving the requirements process live with business stake holders. Getting the requirements right is very important in todays competitive market by helping us keep the costs down and ensuring customers are delighted with the outcome.
*“E-Cometa is a platform designed for the front end, enabling you to generate and maintain your forms on the fly, as well as define and manage processes dynamically. For back-end operations, GenAI allows you to define databases using AI and seamlessly integrate them with ApiLogicServer (ALS). ALS then provides the capability to add simple rules, enabling the creation of complex systems that integrate with your data.
By combining both, you will get a very flexible and powerful solution that allows you to create any web and mobile app easily, making it simple to develop and maintain—even if you are not a technical expert.
We also want to thank ALS for making it possible to migrate from the obsolete Live API Creator (a back-end rules engine with RESTful services), ensuring we could continue innovating with a modern and reliable solution.”*
