Fully Customizable Rule Authoring and Evaluation

Enterprise decision systems rarely fit into a single predefined workflow, terminology model, or user experience. Different organizations operate with:

  • different business vocabularies
  • different compliance requirements
  • different UI standards
  • different localization needs
  • different validation rules
  • different operational semantics
  • different evaluation policies
  • different security models and approval processes
  • different expectations of how AI takes part in their work

For decision automation infrastructure to become part of a long-term enterprise platform, customization cannot be treated as an afterthought. It must exist as part of the architecture itself.

Code Effects was designed specifically around this principle.

Virtually every aspect of rule authoring, editor behavior, UI presentation, terminology, and rule evaluation can be customized, extended, localized, filtered, or dynamically controlled without requiring organizations to fork the platform or rebuild the editor from scratch. Version 7 carries the same principle into rule management: the optional Rule Repository, Audit and MCP server follow your application’s text, design, users, permissions, database and AI models instead of imposing their own.

Designed as a Framework, Not a Fixed UI

Many business rules systems expose a rigid authoring interface with limited configuration capabilities. Typical customization options are often restricted to:

  • color themes
  • logo replacement
  • static field visibility
  • limited localization
  • fixed rule semantics
  • a vendor-defined user and role model

Code Effects takes a fundamentally different approach. The platform was designed as a customizable decision-authoring framework rather than a predefined rule-authoring application. Organizations retain control over:

  • rule terminology
  • editor behavior
  • UI presentation
  • menu generation
  • field visibility
  • evaluation parameters
  • localization strategy
  • validation rules
  • execution semantics
  • rule storage, or the database the Rule Repository uses
  • who may change, test, approve and publish each rule
  • which AI models work with the rules, and what AI may do

This allows the rules platform to adapt naturally to the organization’s own operational and domain requirements rather than forcing users into vendor-defined workflows.

The same holds for how much of the platform you adopt. In a stand-alone implementation, the Rule Editor and the Rule Engine are placed in screens of your own design, and your application decides how rules are stored, versioned and tested. With the Rule Repository, a complete rule management application runs in one element of your own page, on your own sign-in, against a SQL Server or PostgreSQL database you own. See Code Effects Implementation for both options.

Full Multilingual and Terminology Customization

Version 7 continues the Code Effects approach of providing complete control over rule-authoring language and terminology. Organizations can dynamically customize or translate virtually every UI element of the editor, including:

  • field display names
  • in-rule method display names
  • rule action method display names
  • field, method and parameter descriptions shown as help text and tooltips
  • operators
  • rule-related terminology
  • validation and error messages
  • editor labels
  • UI prompts
  • system-generated text
  • menu structures and labels

This includes the ability to override the default rule terminology adopted by Code Effects itself, through the HelpXML configuration that defines all labels and messages of the editor.

In version 7, the Rule Repository’s own text, its editors and the source labels can be translated as well. The repository takes all of its text from a single translatable XML file, so its grids, dialogs, confirmations and messages speak the same language and terminology as the rest of your application. See UI Text and Themes.

Terminology customization now extends to AI as well. Version 7 source objects can carry member-level aliases and descriptions meant for AI agents, giving them the business context they need without changing the labels users see, and the AI Rule Editor in the Rule Repository accepts instructions in any language.

Localization Without Language-Specific Assemblies

Most enterprise software platforms implement multilingual support through language-specific resource assemblies tied to application builds and deployment pipelines. Code Effects intentionally avoids this model. Instead, the platform supports dynamic localization using simple configuration files and runtime translation sources. Organizations can localize the editor dynamically without:

  • recompiling applications
  • deploying language-specific binaries
  • maintaining separate assemblies
  • rebuilding deployment packages for each required culture or locale
  • coupling localization to application releases

This architecture is particularly valuable in environments involving:

  • multilingual SaaS platforms
  • dynamically changing user locales
  • white-label systems
  • customer-specific terminology
  • runtime language switching
  • distributed enterprise deployments

Localized configurations can be loaded per request or per user, enabling the UI to adapt dynamically to each user’s preferred culture. One deployment can serve users in different countries, or different customers with their own terminology, from the same rules and the same source objects.

The rules themselves are not affected by translation. A rule is stored as Rule XML that refers to the members of its source object, not to the words shown on the screen, so the same rule can be read in English by one user and in any other language by the next.

Complete UI Styling Control

The default web-based editor UI supplied by Code Effects is fully customizable. Organizations can completely alter the editor’s:

  • colors
  • layouts
  • Date and Time pickers
  • offset and duration pickers
  • Prompt dialog
  • spacing
  • menus
  • control styling
  • responsive behavior
  • branding appearance

by modifying the default CSS styles provided by Code Effects as an npm package. The editor becomes visually consistent with the surrounding application architecture and design system. See CSS Styles.

Version 7 also provides light and dark themes for the editor and the Rule Repository, with separate common, light and dark stylesheets. Both components inherit your page’s fonts, size their text in percentages, and adjust their layouts to tablets and phones. They are delivered as dependency-free npm packages, @codeeffects/editor and @codeeffects/repository, built on modern JavaScript modules, and they work with React, Angular and Vue as well as plain pages.

Styling control does not come at the expense of security. Names, descriptions and values are always rendered as text, the interface is built without HTML strings, and both the Rule Editor and the Rule Repository support pages that enforce Trusted Types and a Content Security Policy without inline styles.

Adaptive UI and Dynamic Menu Behavior

Version 6 introduced Adaptive Source for context-aware dynamic rule authoring. Using Adaptive Source, organizations can dynamically customize:

  • available fields
  • operators
  • methods
  • actions
  • menu groupings
  • rule flows
  • context-sensitive UI behavior

based on the current rule state and application logic. Menu generation can be controlled by:

  • deterministic business logic
  • AI systems
  • metadata engines
  • runtime policies
  • tenant configuration
  • user permissions
  • operational context

Context Resetters recalculate the editor’s context when users change or remove earlier choices, and Dynamic Menu Data Sources fill menus with values your own code supplies, now consistently on the server in version 7. The editor itself stays deterministic: whatever logic or AI service decides what appears next, users can only choose what your data allows.

In version 7, the Rule Repository works with .NET types, Source XML and Adaptive Sources alike, through a unified source provider that also supplies source identity and the inline and reusable rules offered in the editor’s menus.

Advanced Evaluation Customization

Customization in Code Effects extends beyond UI behavior into rule evaluation itself. Organizations can customize evaluation behavior for different value types and operational scenarios, including:

  • minimum and maximum value constraints
  • numeric validation policies
  • evaluation rounding behavior
  • string comparison options
  • case sensitivity rules
  • culture-specific evaluation logic
  • null handling behavior
  • date comparison semantics
  • date-only, time-only, offset and duration values
  • operator availability
  • menu filtering
  • menu grouping
  • validation policies
  • parentheses grouping logic
  • context-resetting fields
  • logical grouping semantics
  • trusted assemblies allowed to declare in-rule methods and rule actions

This allows rule execution behavior to align precisely with organizational requirements rather than relying on fixed vendor-defined evaluation semantics.

Version 7 adds source metadata that customizes how rules are tested and investigated as well. Methods and actions can name substitute methods that replace operations which should not execute during a test, and a source can designate a correlation field, such as a loan number, that ties recorded production decisions to a particular business case. With the optional Audit library, your application also decides whether all values read during an evaluation are recorded, or only the values you select.

Rule Management That Follows Your Application

Customization in version 7 reaches the parts of decision automation that most platforms define for you: who the users are, what each of them may do, and how a rule reaches production. The Rule Repository has no users or passwords of its own. Your application supplies, on every request:

  • the identity of the current user
  • the user’s permissions, from a set of 37
  • the sources and rules the user works with
  • the AI models available to the user, if any

Permissions can reflect your organization’s identities, roles, tenants and access policies, and they are enforced both in the interface, where unavailable actions are disabled, and on the server, where unauthorized requests are rejected. The decision workflow of request approval, approve or decline, Go Live and Take Offline is allowed step by step only to the users you choose, and notifications keep your application informed so it can route work through its own processes.

Storage is yours as well. The repository keeps rules, versions, tests and decision records in a SQL Server or PostgreSQL database you own, with Oracle and MySQL support planned for upcoming minor versions. Database scripts are provided by Code Effects and run when you decide.

AI Configured by Your Application

AI is part of rule authoring, testing and investigation across the platform, and every AI feature is configured by your application:

  • Prompted rule elements call any LLM of your choice, including a self-hosted or local model
  • the AI Rule Editor and the AI Assistant in the Rule Repository use the models your application registers, with your own API keys
  • the optional MCP server lets external AI agents sign in through your application’s own OAuth authentication
  • AI access follows the same permissions as the person the AI works for

The AI Rule Editor writes or changes a rule from instructions in any language, next to the standard editor. The AI Assistant finds and explains rules, creates rules, versions, drafts and tests, runs tests, and answers questions about rules, recorded decisions, activity and uploaded PDF policy documents. Any model that supports tool calling can be registered, and Anthropic’s Claude and OpenAI’s GPT models have been tested. See AI Assistant and AI Rule Editor.

Some things are deliberately not configurable. Every rule written by AI is validated against its structure and its source object, and structurally invalid logic is rejected with feedback. AI agents and services can never delete, approve, put a rule into production or take it offline, even if those permissions are granted by mistake, and every AI save requests approval. Structural validity is guaranteed; whether a rule expresses the intended business policy is still confirmed by testing and review.

White-Label and OEM Readiness

Because the editor UI, terminology model, localization system, and evaluation behavior are fully customizable, Code Effects is particularly well-suited for:

  • OEM integrations
  • white-label platforms
  • customer-facing SaaS systems
  • embedded enterprise products
  • multi-tenant environments
  • branded workflow systems
  • field-service applications
  • public-facing pages where untrained visitors build their own rules or data filters

Organizations can expose decision authoring to their own customers. The platform becomes part of the product itself rather than an externally recognizable third-party tool. With the Rule Repository, they can expose complete rule management in the same way: in their own pages, in their own language and themes, on their own sign-in.

No component calls a Code Effects service, and your rules and data stay in your systems. Licenses are perpetual, and organizations that need even deeper control can license the source code of the engine and the editor, or of the entire platform. See Code Effects Packages.

The result is a decision automation platform capable of integrating naturally into virtually any enterprise architecture, operational workflow, or product experience without imposing fixed vendor-defined constraints.

l102

p101

×