GenAI, Agentic Execution and Governance via Rule Engine and IDE

TL;DR GenAI-Logic uses GenAI to create executable systems: databases, APIs, Logic and Apps.  Logic is translated into rules you can review in your IDE for governance.  Rules are 40X more concise than code, which simplifies review and maintenance.  The resultant systems - Business Logic Agents - are predictable and standards-based.

GenAI, Agentic Execution, Governance

The process shown here involved several familiar aspects of AI technology: GenAI creation, Governance, and Agentic Execution:

1. GenAI Creation - use your Browser to provide Natural Language prompts (see above).  This creates complete Kickstart systems.  Iterate, and request logic suggestions from GenAI.

2. AI Governance - use your IDE for "human in the loop" review.  Extend using standard Python and libraries.  Create containers for standard deployment.  This addresses the "probabilistic" nature of GenAI, since the creation results in rules with predictable behavior.

3. Agentic Operation - the created Business Logic Agent processes APIs and messages, applying the domain logic to ensure integrity, and integration logic to interoperate with systems and services.

For more information, see the Reference Implementation description.

No Franken-Prompt

AI has proven to be a powerful tool for automating function-level coding. However, creating complete sub-systems - like an App or API - is less successful.  It requires voluminous language input for low-level implementation details. It also requires substantial skill (e.g., detailed knowledge of a framework).  In short, a Franken-Prompt. 

Models - Not Franken-Code

The system specifications for logic are not used to generate traditional code.  Our standard Check Credit example would explode 5 lines of logic into 200 lines of Franken-Code. Programmers are rightfully wary of such approaches: difficult to understand, maintain and debug.

Instead, the logic is transformed as shown below, using Python as a DSL for the LogicBank rules engine. The resultant systems are easy to maintain, and extend where necessary using standard languages and tools. This approach is unique in the industry, and has been proven in a wide range of applications.

  # Ensure that a customer's balance is less than their credit limit.
  Rule.constraint(validate=Customer,
              as_condition=lambda row: row.balance <= row.credit_limit,
              error_msg="Customer balance ({row.balance}) exceeds credit limit")

  # Calculates the customer's balance - sum of the unshipped orders' total amounts
  Rule.sum(derive=Customer.balance, as_sum_of=Order.amount_total,
              where=lambda row: row.date_shipped is None)

  # Calculates the order's total amount as the sum of its items' amounts.
  Rule.sum(derive=Order.amount_total, as_sum_of=Item.amount)

   # Calculates the item amount as the product of its quantity and unit price.
  Rule.formula(derive=Item.amount,
              as_expression=lambda row: row.quantity * row.unit_price)

  # Copies the unit price of the item from the associated product.
  Rule.copy(derive=Item.unit_price, from_parent=Product.unit_price)

Complexity Management

Such logic is complex.  AI, used in the absence of a rule engine, produces code that is incorrect and non-performant - see here.

GenAI-Logic also provides the full power of using your development tools, so there's no 'ceiling' on what you can accomplish.

For more, see GenAI Governance.

Low Code Jump-Started,  Dev-Friendly with GenAI-Logic

TL;DR Low Code and GenAI-Logic are complementary technologies.  Use GenAI-Logic to jumpstart projects with logic, and use Low Code to deliver high-end user interfaces, process logic, etc. Created projects are dev-friendly, leveraging existing dev and deployment tools.

The Low Code promise of business agility has tremendous potential. It is fully realized when combined with GenAI logic, providing significant value to Low Code Business Users, and for Developers:

• For Low Code Business Users, GenAI-Logic provides the fastest and simplest way to kickstart a project with Working Software: 

  • Fastest and simplest way to kickstart a project

    1. • 1. 1. 1. Natural Language - zero learning curve

               2. No screen painting is required

               3. No database definition -- the full system is automated from GenAI

       • Logic - Declarative Rules with Natural Language for the backend half of the system

       • Full Access to Low Code value: screen painters, process, deployment...

       • When required, excellent dev partnership...

• For Developers, GenAI-Logic leverages your existing infrastructure, including 

  • Your IDE (code editors, debuggers), existing libraries, tools and

  • Flexible container-based deployment

• For both, GenAI-Logic provides unique Logic Automation with spreadsheet-like rules - 40X more concise

  • Such backend logic is half of your system - front-end-only automation falls short

This results in a running project, in minutes, which can iterated to get the requirements right.  

Further, the result is not throw-away: it's a complete API Server that enforces your business logic.  Low Code Users can use this instantly for custom User Interfaces using visual screen painters, Process Logic using visual flow diagrams, etc.

TL;DR - No, optimized for transaction processing

The API Logic Server engine is not based on the RETE algorithm. These technolgies are complemetarty:

• RETE is appropriate for Decision Logic, where there are no presumptions about a database

• API Logic Server optimizes performance, often by several orders of magnitude, since it can prune and optimize rule execution based on comparing the proposed / old state of the database.

For more information, click here.

TL;DR - no, rather, a low-code approach for creating systems

There are many excellent frameworks for developing web apps. They provide tools for writing code to handle API and application events.

API Logic Server is not a framework - it is built on frameworks (Flask currently, more are possible). It is a low-code approach for creating customizable microservices - Apps, APIs, and (uniquely) the underlying business logic.

For more information, click here.