AI-Powered Rule Authoring Platform

Overview

The Common Workflow platform was built on a powerful rule-driven architecture that enabled workflow UIs to be dynamic, configurable, and reusable across multiple eCat applications.

However, as the platform expanded, rule creation became one of the most complex parts of workflow development. Developers needed deep understanding of rule properties, rule tables, dependencies, functions, backend execution, and how UI components consumed rule outputs.

In practice, this meant that only experienced rule authors could confidently create or maintain workflow behavior.

To solve this, we built an AI-powered rule authoring platform that simplified the entire rule creation process. Instead of manually configuring rule tables and writing complex logic, users could describe the desired UI behavior in natural language, while AI agents generated the required technical implementation behind the scenes.

The platform later became a foundational capability for the broader AI-assisted workflow ecosystem, with its APIs consumed by other workflow-generation agents.

The Challenge

The Common Workflow UI relied heavily on rules to control application behavior, including:

• Field visibility

• Validation

• Enablement and disablement

• Interdependent field behavior

• Conditional actions

• Default values

• Dynamic UI updates

While this architecture made the framework highly flexible, it also created a major adoption challenge.

Creating rules required developers to understand:

• Rule properties used by the UI

• Rule-table structure

• Interdependent rule behavior

• Function logic

• Backend rule execution

• How frontend components consume rule outputs

• How UI state changes affect workflow behavior

• How rules should be validated across different scenarios

As a result, workflow creation became heavily dependent on a small group of specialist rule authors, slowing delivery and increasing support overhead across global teams.

The goal was to make rule creation accessible to anyone who understood the desired UI behavior, even without deep knowledge of the underlying rule engine.

The Solution

We built an AI-powered rule authoring platform that acts as an intelligent layer between users and the underlying rules engine.

Instead of manually creating technical rule artifacts, users could simply describe the behavior they wanted on the UI. The platform then used AI agents to generate the required rule properties, rule tables, functions, dependencies, and workflow behavior automatically.

The system allowed users to:

• Create rule-driven UI behavior using natural language

• Generate rule properties automatically

• Produce rule tables without manual configuration

• Define interdependent field behavior

• Generate function logic using AI assistance

• Validate generated rules against expected outcomes

• Connect generated rules back to Common Workflow UI components

• Reuse generated rule APIs inside other AI workflow-generation systems

This transformed rule creation from a specialist-driven engineering task into a guided AI-assisted experience.

Simplifying Agentic Workflow Creation

A major part of the project focused on improving how AI agents interacted with the Common Workflow ecosystem.

We created reusable feature components and exposed them directly to AI agents. These components represented reusable workflow building blocks such as:

• Form sections

• Input fields

• Rule-enabled controls

• Validation areas

• Action panels

• Workflow layouts

• Dynamic UI patterns

By giving AI agents access to structured feature components, workflow generation became significantly more reliable and maintainable.

Instead of generating workflows entirely from scratch, agents could now:

• Select appropriate feature components

• Configure components based on user intent or design input

• Attach generated rule properties to UI elements

• Consume APIs from the AI rule authoring platform

• Produce workflows closer to production-ready output

This created a cleaner separation between UI structure, business behavior, and AI-generated configuration.

Architecture

The platform was designed using a multi-layer architecture that combined frontend experience, AI orchestration, and backend rule execution.

Frontend

The frontend was built with React and provided an intuitive interface where users could:

• Describe expected UI behavior

• Review generated rules

• Validate outputs

• Refine generated logic

• Interact with workflows without understanding the full complexity of the rules engine

Backend

The backend was built using FastAPI and acted as the orchestration layer for:

• AI agents

• User requests

• Rule generation

• Rules engine communication

• API coordination

Rules Engine

The core rules engine was built in .NET and handled:

• Rule validation

• Rule execution

• Dependency resolution

• Output generation

The FastAPI layer communicated directly with the .NET engine to generate and validate rule behavior.

AI Agent Layer

AI agents acted as the intelligent layer between user intent and technical rule implementation.

The agents were responsible for:

• Understanding requested UI behavior

• Generating rule properties

• Producing rule tables and function logic

• Validating generated outputs

• Coordinating with backend APIs

• Exposing reusable APIs to other workflow-generation agents

High-Level Workflow

1. User describes the desired UI behavior

2. React frontend sends the request to FastAPI

3. FastAPI coordinates with AI agents

4. AI agents generate rule properties, dependencies, and logic

5. Backend communicates with the .NET rules engine

6. Rules engine validates and produces outputs

7. Generated rules are returned to the frontend

8. Other AI workflow agents can consume generated APIs and rule outputs

Technologies Used

• React

• FastAPI

• Python

• AI Agents

• .NET Rules Engine

• REST APIs

• Configuration-Driven Architecture

• Rule-Based UI System

Challenges

One of the biggest challenges was translating user intent into accurate and reliable rule behavior.

Rules were deeply connected to:

• UI state

• Backend data

• Workflow execution

• Field dependencies

• Business logic

Even small mistakes in generated rule properties could affect validation, visibility, or workflow execution behavior.

Another challenge was designing a system that worked for both technical and non-technical users. Developers needed flexibility and precision, while designers and workflow creators needed simplicity and abstraction from the underlying complexity.

The platform also needed to function as a reusable capability for other AI agents, rather than only as a standalone application.

Impact

The AI-powered rule authoring platform significantly reduced the complexity of building rule-driven UI behavior across the Common Workflow ecosystem.

Key outcomes included:

• Reduced dependency on specialist rule authors

• Simplified creation of rule-driven UI behavior

• Replaced manual rule-table creation with AI-assisted generation

• Improved consistency across generated rule properties

• Enabled designers and workflow creators to participate in workflow configuration

• Reduced onboarding complexity for regional development teams

• Accelerated workflow generation across global teams

• Enabled reusable APIs for other workflow-generation agents

• Improved scalability and maintainability of the Common Workflow platform

What previously required deep understanding of internal rule systems could now be generated through AI-assisted workflows and reusable configuration patterns.

Final Result

This project transformed one of the most difficult parts of Common Workflow adoption into an accessible AI-assisted experience.

Earlier, creating rule-driven UI behavior required specialized knowledge of rule properties, rule tables, functions, dependencies, and backend execution.

With the new platform, users could simply describe the behavior they wanted, while AI agents generated the required technical implementation behind the scenes.

The result was a more scalable, intelligent, and collaborative workflow ecosystem where developers, designers, and AI agents could work together to build sophisticated rule-driven workflows with significantly less manual effort.