Executable Requirements, EAI Automation from Coding Assistant

This major release provides 2 significant features:

1. Executable Requirements: provide a directory of NL requirements, including logic and EAI services - for docs, click here

2. Enterprise Application Integration Services: create listeners and test/reset debug services from NL, by providing sample formats and exception mappings. Automated 2-message protocol ensures messages are not lost - for docs, click here

Doc excerpts below.

 

---

Executable Requirements

What It Is

Traditional requirements are a handoff artifact: a document a developer reads, interprets, and then implements. Interpretation introduces drift — requirements that describe intent, code that approximates it.

Executable Requirements treats requirements.md as direct AI input. The AI reads the file and produces a running system — Python source, database, REST API, business logic, tests. Not a prototype. Not a scaffold. A running system you own, in your IDE, in your source control.

Behavior is added incrementally: drop a new requirements file into docs/requirements/<name>, tell the AI to implement it, and it executes that slice on the running system. Each increment builds on the last. The AI reports any decisions it made beyond the spec (the ad-libs report), so you know exactly what was automated and what needs review.

Declarative rules make iteration safe: adding logic for a new use case doesn't disturb existing rules. When a rule changes, you update the declaration; ordering and reuse are automatic.

The demo_eai sample illustrates the process:

1. You execute the steps in the upper right (readme.md) - note the use of Copilot in lower right
2. The key file is requirements.md - bottom left
3. This creates the system summarized in the diagram - top left

 

---

EAI Automation

GenAI-Logic provides multiple approaches for integrations:

• Ad hoc access via automatically created self-serve APIs
• Custom APIs
• Kafka integrations — both outbound publication and inbound message subscription (pub/sub).

 

The Manager helps you build demo_eai, which illustrates creating logic, APIs and Messages using AI (e.g. plain text or Gherkin syntax):

These approaches are typically more efficient than ETL-based integrations:

Integration Approaches

Requirement	Poor Practice	Good Practice	Best Practice	Ideal
Ad Hoc Integration	ETL	APIs	Self-Serve APIs	Automated Self-Serve APIs
Custom APIs			Coded APIs	Create with AI
Messages			Coded Pub/Sub	Create with AI
Logic	Logic in UI		Reusable Logic - any source	Declarative Rules .. Extensible with Python

• APIs should be self-serve: not requiring continuing server development — they avoid the overhead of nightly Extract, Transfer and Load (ETL)

• Logic should be re-used over the UI and API transaction sources — logic embedded in UI controls cannot be shared with APIs and message consumers

 

AI-based creation

Traditional API/Kafka integrations are fiddly — extensive hand-code or complex metadata. With AI, you provide a message shape and name the exceptions; the system maps the rest:

1. Sample message: AI reads the JSON shape and auto-maps obvious fields silently — no entry needed for direct name matches
2. FIELD_EXCEPTIONS — exceptions only: specify renames, dot-notation joins (Customer.name), and child collections; everything else is inferred
3. _unresolved guard: fields AI can't map block server start — no silent failures

For full working examples, see Sample-Basic-EAI.md{:target="_blank" rel="noopener"}.

Copilot System Creation, Enhanced Training

This release provides significant new features described below:

Copilot System Creation

You can create systems from existing database, or use Copilot to create new systems with a database, API, Admin App s logic:

• from business statements: the prompt above creates a sophisticated allocation system that previously required 4 developers 2 years. It allocates charges to departments, and department charges to their General Ledgers
• from regulations: we have created customs systems be referencing public regulations
• from requirements: we have created customs systems from Cucumber require documents.
  For more information, click here

 

Training

We have completed a sophisticated training for a large logistics firm, and are pleased to make the key materials available.

Guided Tour

The Manager opens automatically and walks you through creating basic_demo. Allow 30-45 minutes.

Inside the created project, say to your AI assistant:

"Guide me through basic_demo"

This is a hands-on tour covering API creation, declarative rules, security, and Python customization. The AI acts as a knowledgeable colleague — running commands, explaining what happens, answering questions. Scripts ensure no coding errors. This is the recommended starting point.

 

Key Samples

The Manager provides a full sample catalog, each illustrating key patterns. Each project is AI-enabled — ask your AI assistant how it works.

Note you can create projects from existing databases, or new database projects from prompts. In both cases, the presumption is that development continues in a classic iterative manner in the created project.

 

Ease Of Use

Context Engineering

We continue to add Context Engineering to projects, providing:

• creation: use Copilot to create logic, custom APIs, make database changes, etc
• information: Copilot can explain how things work (e.g., logic), as key design background
• • diagnostics: we now create log information as files, so you can ask copilot for help without have to copy the log to Copilot

For more information, click here

 

New Doc Home Page

We have revised the Doc Home for quick starts, including key orientation on Logic Architecture.

For more information, click here

Enterprise Business Automation

Bug fixes, plus extensive improvements to Context Engineering now enable you to create complete systems from a business oriented prompt. As described in this documentation, this prompt creates a complete customs surtax calculator:

Create a fully functional application and database
 for CBSA Steel Derivative Goods Surtax Order PC Number: 2025-0917 
 on 2025-12-11 and annexed Steel Derivative Goods Surtax Order 
 under subsection 53(2) and paragraph 79(a) of the 
 Customs Tariff program code 25267A to calculate duties and taxes 
 including provincial sales tax or HST where applicable when 
 hs codes, country of origin, customs value, and province code and ship date >= '2025-12-26' 
 and create runnable ui with examples from Germany, US, Japan and China" 
 this prompt created the tables in db.sqlite.

For example, the remarkable command above

• Finds, reads and understands the reference statutes from web-based documents

• Builds an executable GenAI-Logic project, including:

  • A database (including sample data), Admin App and API
  • Business logic, expressed as rules
  • Business documentation

Here is the Admin App:

NL Subsystem Creation

Extensive improvements to Context Engineering now enable you to create complete systems from a business oriented prompt. As described in this documentation, this prompt creates a complete customs surtax calculator:

Create a fully functional application and database
 for CBSA Steel Derivative Goods Surtax Order PC Number: 2025-0917 
 on 2025-12-11 and annexed Steel Derivative Goods Surtax Order 
 under subsection 53(2) and paragraph 79(a) of the 
 Customs Tariff program code 25267A to calculate duties and taxes 
 including provincial sales tax or HST where applicable when 
 hs codes, country of origin, customs value, and province code and ship date >= '2025-12-26' 
 and create runnable ui with examples from Germany, US, Japan and China" 
 this prompt created the tables in db.sqlite.

For example, the remarkable command above

• Finds, reads and understands the reference statutes from web-based documents

• Builds an executable GenAI-Logic project, including:

  • A database (including sample data), Admin App and API
  • Business logic, expressed as rules
  • Business documentation

Here is the Admin App:

Improved Context Engineering

Enables creation subsystems from CoPilot.

Integrated Deterministic and Probabalistic Logic

This release enables you to provide Copilot prompts for logic that include both classic 'deterministic' logic, we well as 'probabilistic' logic:

Use case: Check Credit

1. The Customer's balance is less than the credit limit
2. The Customer's balance is the sum of the Order amount_total where date_shipped is null
3. The Order's amount_total is the sum of the Item amount
4. The Item amount is the quantity * unit_price
5. The Product count suppliers is the sum of the Product Suppliers
6. Use AI to Set Item field unit_price by finding the optimal Product Supplier
   based on cost, lead time, and world conditions

Rule 6 results in a runtime LLM call, for example to obtain a supplier reflecting real-world conditions. For example, a tanker mishap in the Suez Canal might cause you to avoid suppliers in the region.

Critically, the deterministic logic still applies, serving as 'guardrails' on the probabilistic logic. So, an AI attempt to choose a supplier with an exorbitant cost would fail the credit check.

Governed AI

For more on AI Logic, click here.

To see an example you can run, click here.

Copilot NL Update via MCP

Copilot uses MCP discovery to create, interact with, and enforce logic in GenAI-Logic projects

Prompt 1 (Create System):

Create a system named basic_demo from samples/dbs/basic_demo.sqlite

Prompt 2 (Add NL Logic):

Use case: Check Credit:

1. Customer's balance is less than credit limit

2. Customer's balance is sum of Order amount_total where date_shipped is null

3. Order's amount_total is sum of Item amount

4. Item amount is quantity * unit_price

5. Item unit_price is copied from Product unit_price

Prompt 3 (Test via MCP-discovered API): Constraint blocks bad data -- as shown below: 🛡️

On Alice's first order, update the widget quantity to 100
 

 

For more information, click here.

15.02.10

This release is a technology preview for automatic test creation and an AI-driven tutorial.

AI Test Creation

You can create tests using AI, based on logic and custom APIs, with fixes for issues [103, 104, 105]. Test creation creates:

• A set of Behave tests
• Their implementations (steps)
• A Test Suite
• A Report Generation showing Requirements Traceability: for each scenario, see the rules that fired, and optionally the log showing chaining.

To see the docs, click here.

To see an example, click here.

AI-driven Tutorial

It's been clear for quite some time that lab-based training was far superior to death by powerpoint. But running labs is not simple - it usually requires in-person expertise to deal with inevitable problems.

AI enables us to put a "message in a bottle" - an AI genie that can walk you through the tutorial, and, unlike a readme, support you:

• answer questions ("how do I customize this")
• get you unstuck ("ah, you forgot to start the server")

With this release, when you create the manager, the system will offer to start the tutorial - click here for more information.

Ed: this was an interesting technical problem - AI prefers to be passive (not driving a tutorial), and make decisions about 'that seems to be working'. We had to convince AI to act outside its comfort zone. To read more, click here.

Test Creation, AI-driven tutorial

This release is a technology preview for automatic test creation using AI, based on logic and custom APIs, with fixes for issues [103, 104, 105]. Test creation creates:

• A set of Behave tests
• Their implementations (steps)
• A Test Suite
• A Report Generation showing Requirements Traceability: for each scenario, see the rules that fired, and optionally the log showing chaining.

To see the docs, click here.

To see an example, click here.

We are also testing an AI-Driven tutorial - create the manager, load the copilot instructions, and it will lead you through it

15.02.03

This release is a technology preview for automatic test creation using AI, based on logic and custom APIs, with fixes for issues [103, 104]. Test creation creates:

• A set of Behave tests
• Their implementations (steps)
• A Test Suite
• A Report Generation showing Requirements Traceability: for each scenario, see the rules that fired, and optionally the log showing chaining.

To see the docs, click here.

To see an example, click here.