Governance by Architecture,
Not Discipline.
Governance by Architecture,
Not Discipline.
Unlocks Enterprise AI.
Unlocks Enterprise AI.
Embedded Files
Not Discipline.
Two Funnels.
One Commit Point.
The right rules, enforced on every path.
Provably. No Bypass.
Two Funnels.
One Commit Point.
The right rules, enforced on every path.
Provably. No Bypass.
AI Delivers. One Thing Was Missing.
AI Delivers. One Thing Was Missing.
AI Creates Working Software
AI Creates Working Software
AI can translate this intent into working software: database, API, App.
Governance Gap
Governance Gap
While truly remarkable, deployment requires we address:
Bugs: there were some subtle bugs (e.g., order not repriced on part substitution - see the A/B Test)
Path Bypass: tomorrow's new code might bypass yesterday's logic
Not Auditable: intent is lost in ~200 lines of FrankenCode
Not Scalable: each change requires generating all the code. At 500 rules - a modest system - significant risk of hallucinations and missed dependencies.
Governance Architecture To Unlock Enterprise AI
Governance Architecture To Unlock Enterprise AI
The Missing Infrastructure for AI Speed, Enterprise-Class Quality.
The Missing Infrastructure for AI Speed, Enterprise-Class Quality.
Logic Governance Architecture
Logic Governance Architecture
Context Engineering directs AI to generate Data Rules — not procedural code. It travels with every project — a trained collaborator, able to guide implementation, answer questions, and debug — throughout the project. When something goes wrong, CE reads the logs and diagnoses rule execution in plain language.
Data Rules distill path-dependent logic into path-independent rules on data. 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 →]
Data Rules - Concise, Spreadsheet-like Expressions
Data Rules - Concise, Spreadsheet-like Expressions
Where Governance Becomes Executable
Where Governance Becomes Executable
Rules Govern Business Policy — multi-table derivations, constraints, actions (e.g, send message).
Automatic Reuse — path independent
Automatic Invocation — executed on commit - no bypass... future paths included.
Automatic Dependencies — engine computes dependency order at startup, deterministically. Add a rule, change a rule, remove a rule — the engine finds its place. No impact analysis, no archaeology, no missed paths.
Familiar tools — Python, your IDE, your debugger, your source control, deploy as a stateless container. Rules live in the repo like everything else. No proprietary lock-in, no new stack to learn. The rules AI produces are human-readable Python — reviewed, version-controlled, and auditable before they run.
Optimized — Non-RETE engine, purpose-built for transactional performance at commit. RETE engines re-evaluate all rules against all rows — they have no idea what changed. This engine sees the actual change event, prunes irrelevant rules, and maintains aggregates incrementally. In production: four-minute transactions became two-second transactions. The same division of labor that made SQL and spreadsheets succeed: you specify what, the engine figures out how, at enterprise scale.
Read the Technical Deep-Dive: Why we chose a Transactional Engine over RETE: click here.
When the rule is the requirement, governance becomes a strategic asset — not a discipline you enforce, but an architecture you deploy.
Governance, In Action
Governance, In Action
Executable Requirements: Familiar Inputs → Working Enterprise Systems
Executable Requirements: Familiar Inputs → Working Enterprise Systems
Requirements describe intent using familiar inputs such as Gherkin. Analysts write what they already write. Developers use Python they already know. Context Engineering handles the declarative translation — no paradigm shift required.
This creates a working system - API, message handlers, an admin app, and logic.
It works on existing enterprise infrastructure — existing sql databases, existing message brokers, existing security. No rip and replace.
The resultant system is fully governed, by readable rules executing at commit time for all paths.
The deck walks this through end-to-end using a real integration example.
→ Click to see the architecture at work.
Real-World Case Studies
Real-World Case Studies
Allocation System
Allocation System
Multi-table charge allocation across departments and GL accounts — the kind of chaining logic that defeats procedural code. A plain-English prompt produces the rules, the logic diagram, and a running system. Declared once, correct on every transaction, automatically.
Customs Surtax
Customs Surtax
A Canadian customs regulation — cited directly, as written — compiled into a governed, running system. No requirements pass. No developer interpretation. Regulation in, governed system out.
Customs CLVS
Customs CLVS
The rules are published and readable — no code archaeology, guaranteed to execute on every transaction. Where AI had to make a judgment call, an ad-lib report flags it for human review. Compliance exposure in existing production code that years of manual oversight had missed — an 8-figure exposure — became visible the moment the system was created.
With Governance Architecture, Look What Falls Out For Free
With Governance Architecture, Look What Falls Out For Free
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.
Free and open source - install and explore these samples
Managing Governance: Visible, Measurable, Reportable
Managing Governance: Visible, Measurable, Reportable
Governance You Can Prove, Not Just Assert
Governance You Can Prove, Not Just Assert
Logic Diagram — one per requirement, generated from running rules. Pruned to only the tables it touches. A compliance officer can verify implementation in minutes.
Test Report / Traceability — tests generated from the rules, not hand-written against them. Every transaction traced: requirement → rule → execution log. Compliance proven, not asserted.
Health Check — coverage and integrity scores across the portfolio. Where governance is strong, where it's weak — without reading a line of code.
Because logic is captured as structured rule objects, all three generate automatically — and can't drift from the code.
Use Case 1: AI Rules
AI reasoning at runtime, governed at commit. The agent proposes; the rules engine validates before anything persists.
Use Case 1: AI Rules
AI reasoning at runtime, governed at commit. The agent proposes; the rules engine validates before anything persists.
Most rules — derivations, constraints, aggregations — are declared with AI but execute without it. Deterministic, always.
AI Rules are different: explicitly declared to invoke AI reasoning at runtime. For example:
Use AI to Set Item field unit_price by finding the optimal Product Supplier based on cost, lead time, and world conditions
For example, if the Suez Canal is blocked, choose higher-priced suppliers other than Cairo
Governance
Governance
AI can make mistakes, so governance is mandatory:
Results subjected to deterministic logic, automatically
Results audited to database (see slides
Use Case 2: Governed MCP Server
MCP-discoverable API with business rules enforced on every request. Agents find it and use it; governance travels with it.
Use Case 2: Governed MCP Server
MCP-discoverable API with business rules enforced on every request. Agents find it and use it; governance travels with it.
MCP servers without governed logic are a liability — agents can read and write production data with no rules enforced.
GenAI-Logic creates a governed MCP server from your existing database.
Working in 10 minutes - see the full steps at right.
Business logic declared once, enforced on every agent request, automatically.
Fully audited.
1. Create MCP Backend for Existing Database:
1. Create MCP Backend for Existing Database:
genai-logic create --project_name=basic_demo --db_url=sqlite:///samples/dbs/basic_demo.sqlite
2. Run Server and Verify:
2. Run Server and Verify:
cd basic_demo
sh run.sh
To verify, paste this into your AI Assistant:
Using mcp discovery, list the customers with a positive balance.
3. Declare Business Logic using Natural Language
3. Declare Business Logic using Natural Language
See here for details on how to use Natural Language to:
Create multi-table logic for governance (e.g. email opt-out)
Create an audited email service
Create MCP client (shown below)
4. Business Users Create New Orchestrations with NL
4. Business Users Create New Orchestrations with NL
Use Case 3: Governed EAI - APIs and Messages
Inbound messages hit the same commit boundary as API calls. No separate logic layer, no separate governance.
Use Case 3: Governed EAI - APIs and Messages
Inbound messages hit the same commit boundary as API calls. No separate logic layer, no separate governance.
EAI Light — Free, Simple, Governed
EAI Light — Free, Simple, Governed
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 →
Use Case 4: Making Vibe Enterprise Safe
Vibe tools generate the UI; GenAI-Logic governs the backend. Logic inherited automatically, not rebuilt per app.
Use Case 4: Making Vibe Enterprise Safe
Vibe tools generate the UI; GenAI-Logic governs the backend. Logic inherited automatically, not rebuilt per app.
Enterprise AI Automation
Enterprise AI Automation
Vibe tools generate beautiful UIs but need enterprise-class backends.
Vibe tools generate beautiful UIs but need enterprise-class backends.
GenAI-Logic and your favorite Vibe tools are the dream team:
GenAI-Logic and your favorite Vibe tools are the dream team:
GenAI-Logic creates backends instantly, for data access with governance
Vibe your Apps with your favorite Vibe tools using the standard JSON:API
Logic Inherited
Logic Inherited
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.
Parallel Development
Parallel Development
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.
Standard tooling
Standard tooling
AI scaffolds full applications that developers can refine using familiar tools, backed by the deterministic rules engine.
Use Case 5: Business Users
Natural language requests, governed responses. The analyst iterates without waiting for dev.
Use Case 5: Business Users
Natural language requests, governed responses. The analyst iterates without waiting for dev.
Ideal Vibe Companion
Ideal Vibe Companion
Vibe tools generate beautiful UIs but need enterprise-class backends. GenAI-Logic delivers production-ready APIs in seconds—with pagination, filtering, security, and governed logic—so you can focus on the UI.
Vibe tools generate beautiful UIs but need enterprise-class backends. GenAI-Logic delivers production-ready APIs in seconds—with pagination, filtering, security, and governed logic—so you can focus on the UI.
With declarative business logic, creating a system can finally match the way we think about it.
Full-Stack Vibe becomes real.
Full-Stack Vibe becomes real.
With backend logic governed and deterministic, WebGenAI can generate UI, API, data, and logic from natural language.
Business + IT Harmony
Business + IT Harmony
Business users prototype in WebGenAI.
IT receives a standard, extensible backend — not a low-code black box.
Custom UI Vibe
Custom UI Vibe
AI scaffolds full React applications that developers can refine using familiar tools, powered by a deterministic rules engine.
Try It Now
Try It Now
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
Partners
Partners
Fernando Vazquez Nuñez
Fernando Vazquez Nuñez
CEO | Director General
CEO | Director General
(Strategic Partner)
(Strategic Partner)
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.
Mark McLellan Director
Mark McLellan Director
(Partner)
(Partner)
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.
Thomas Peters Founder
Thomas Peters Founder
Imagery Business Systems, LLC
Imagery Business Systems, LLC
(Partner)
(Partner)
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.
César Quinteiro Rendo
César Quinteiro Rendo
CTO Intergal S.Coop. G.
CTO Intergal S.Coop. G.
(Partner)
(Partner)
*“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.”*
Page updated
Google Sites
Report abuse