-
Your Models, Your Keys
The AI features of Code Effects use the models your application chooses instead of a model of its own. The Rule Editor can call any LLM through a client-defined callback, and the Rule Repository uses the models your application registers, with your own API keys and your own choice of provider; any model that supports tool calling can be used, and Anthropic’s Claude and OpenAI’s GPT models have been tested. Decisions about cost, privacy and vendors stay with your organization, and nothing ties your rules to any one AI provider.
-
AI-Aware UI
The Rule Editor adapts in real time to the rule being written, using Adaptive Source to control which fields, operators and options are available at each step. Your callback can consult an LLM to decide what the author sees next and tailor the experience to your domain. The result is a context-aware, AI-assisted authoring environment that reduces errors and streamlines rule creation, while the editor still offers only what your data allows.
-
AI Rule Editor and AI Assistant
New in version 7, the Rule Repository includes two conversational tools that work under each user’s permissions. The AI Rule Editor writes or changes a rule from instructions given in any language, right next to the standard editor, and checks the result against its source object immediately. The AI Assistant works across the entire rule database: it finds and explains rules, creates rules, versions, drafts and tests, runs tests, and answers business questions about rules, recorded decisions and user activity, including questions about the PDF policy documents users upload. Both are part of the Rule Repository library and do not require the MCP server.
-
MCP Server for AI Agents
The optional MCP server, new in version 7, lets the AI clients your people already use work with your rules through the Model Context Protocol. Agents can inspect sources, rules, tests and recorded evaluations, write and test rules, and use the available history for investigation and reporting. They sign in through your application’s own OAuth authentication and work within the same permissions as the person they represent, so AI agents become governed participants in your decision management, not a way around it.
-
Structural Guardrails for AI-Generated Logic
Every rule an AI agent creates is checked against its structure and its source object before it is saved, and structurally invalid logic is rejected with validation feedback the agent can act on. Because Rule XML is a precise, documented format rather than free text or generated code, agents can verify their own work without someone manually reading every result. Structural validity guarantees that a rule is well formed and can run against your data; whether it expresses the intended business policy is still confirmed by testing and review.
-
Human Authority over Critical Actions
AI agents and services can propose, draft and test, but they can never delete, approve, put a rule into production or take it offline, even if the host application grants those permissions by mistake. Every rule an agent saves waits for a person’s approval, and tests that would call production code require confirmation from the person using the agent. AI speeds up the work, while people remain accountable for the business logic that reaches production.
-
Rule Repository
The optional Rule Repository, new in version 7, is a complete rule management application that runs inside your own web application, on your own sign-in, against a SQL Server or PostgreSQL database you own. It brings rule authoring, versions, approvals, testing, notes, activity and production insights into one ready-made workspace placed in a single element of your page. Development teams that would otherwise spend months building storage, versioning and testing around the Rule Editor can typically reach production in days.
-
Source and Rule Versioning
Every saved change creates an immutable rule version linked to the version of the source object it was written against. The Rule Repository creates a new source version only when a change in your classes could change how a stored rule evaluates, such as a renamed field or a changed data type, while display names and descriptions update in place. Users can compare versions side by side, clone them, and move rules to a newer source version, with every element the newer source cannot resolve identified before the logic moves forward.
-
Decision Workflow with Approvals
An explicit decision workflow controls which business logic runs in production. Versions can be submitted for approval, approved, declined or revoked, and each rule has at most one live version: the version your application evaluates. Going live, taking a rule offline and approving require a typed confirmation, and your application decides which of its users may take each step. Together with immutable versions and activity records, this gives your organization clear accountability for every production change.
-
Drafts and What-If Testing
Business users can test a new rule or a proposed version against their own values before saving it, and keep exploring ideas as drafts that never create rule versions. Exploration tests answer what-if questions, while expectation tests define the outcome a rule must produce and report whether it passes. Each run shows the decision path, the conditions that held or failed, and the resulting values. Tests can be saved, built from value templates or from recorded production decisions, and run in batches of up to 350 whenever a rule changes.
-
Decision Explainability with Audit
The optional Audit library, new in version 7, records production evaluations: when each decision ran and for whom, the exact rule and source versions, the values read, the branch taken and the actions that followed. In the Rule Repository, any recorded decision can be opened, replayed step by step and explained, counted in production statistics, and turned into a test using the actual production data. Records are written to a local journal first, so recording never makes a decision wait for the database.
-
Permissions That Follow Your Security Model
The Rule Repository has no users or passwords of its own. Your application tells it who the current user is and what that user may do, from a set of 37 permissions that can reflect your organization’s identities, roles and access policies on every request. Permissions are enforced both in the interface, where unavailable actions are disabled, and on the server, where unauthorized requests are rejected.
-
Activity Records and Notes
Every change in the Rule Repository is recorded with who made it and when, including the person an AI agent acted for. Object descriptions and working notes keep the business reasoning behind each rule next to the rule itself. These records support activity reporting, historical investigation and authorized AI questions about who changed what and what happened next.
-
Flexible Rule Storage
Rules are stored as simple XML strings, allowing them to be persisted in any database, file system, or storage solution of your choice. This removes the need for vendor-specific storage mechanisms or retrieval procedures. The result is a flexible, portable rule model that integrates easily with existing data architectures. Alternatively, the optional Rule Repository keeps rules and their versions in a SQL Server or PostgreSQL database you own, with database scripts you run when you decide and Oracle and MySQL support planned.
-
Built-In Guidance and Validation
The Rule Editor provides real-time guidance as users build rules, surfacing valid next actions, available options, and immediate feedback on errors. This reduces trial-and-error and helps prevent invalid rule configurations before they are saved. Every saved rule is structurally valid against its source object, whoever or whatever wrote it, because the server checks it again before the Rule XML is produced, including checks for circular references between rules. The result is a more efficient authoring experience with fewer mistakes and higher-quality rules.
-
Human-Readable Rule Logic
Business rules are presented in a clean, human-readable UI, allowing both technical and non-technical users to understand decision logic instantly by simply reading it, without dealing with cryptic formats or programming terminology. Rule conditions are built using fields from your domain model, displayed and described in the user’s preferred language rather than in code syntax. A complete rule, including one written by an AI agent, is shown in its entirety in the same readable form, without fragments, special representations or diagrams to assemble.
-
A Richer Rule Language
Version 7 makes more decisions expressible as single, readable rules. Membership conditions such as Status is in (Active, Pending) replace chains of alternatives, is between includes both bounds and has an exact opposite in is not between, and one Collections menu offers exists, does not exist, all, first, last, count and count with. Rules can also compose strings with Concatenate and shift dates by days, months or years, as in Order Date + 30 days, bringing familiar business calculations directly into the rule.
-
Dates, Times and Durations
Rules work with dates, date-only values, times of day, and dates and times with a UTC offset, each with a picker that never lets users type an invalid value. A date shown without a time is compared by its date, and an offset value is compared by the moment it stands for. Durations have their own operators, such as is longer than, and their own picker in the units configured for the field, so a length of time is never confused with a time of day.
-
Evaluation and Execution Rule Types
Supports two complementary rule types to cover different decision scenarios. Evaluation rules return a deterministic Boolean result and are used for validation, filtering, and conditional logic. Execution rules can invoke .NET methods (rule actions) and set data values based on evaluation results, enabling workflows, state changes, and other side-effect-driven operations within your application.
-
Reusable and Inline Rules
Evaluation rules can be defined once and reused as conditions in rules of any type, and in version 7 execution rules can run other execution rules from their THEN and ELSE sections as inline rules. Larger decisions are composed from established logic instead of copying it, which reduces duplication, simplifies maintenance, and ensures consistent behavior across systems. In the Rule Repository, a rule calls the live version of the rule it references, and changes that would create a circular dependency or break a calling rule are prevented.
-
Logical Grouping with Parentheses
Rules support explicit grouping of conditions using parentheses, allowing complex logic to be structured into clear, well-defined segments. This enables precise control over evaluation order and improves readability of advanced rule expressions.
-
Multi-Source Data Architecture
Supports multiple source types to fit different integration scenarios, including direct use of .NET classes via reflection, Source XML schemas for data description, FlexSource for dynamic data modeling, and Adaptive Source for context-aware, AI-assisted authoring. In version 7, sources can also carry member aliases and descriptions that give AI agents business context without changing the labels users see, substitute methods for testing, and a correlation field, such as a loan number, that ties recorded decisions to a business case. The result is a consistent rule model across diverse systems without requiring changes to underlying data implementations.
-
Configurable Multilingual Support
The Rule Editor supports multilingual UI through an XML-based configuration that defines all labels and messages. Default English terminology can be easily customized or fully translated into any language, and the Rule Repository takes all of its text from a single translatable XML file as well. Localized configurations can be loaded per user, enabling the UI to adapt dynamically to each user’s preferred culture, while the AI Rule Editor accepts instructions in any language.
-
An Interface That Fits Your Brand
The Rule Editor and the Rule Repository come with light and dark themes, inherit your page’s fonts, size their text in percentages, and adjust their layouts to tablets and phones. Both are delivered as dependency-free npm packages built on modern JavaScript modules, and they work with React, Angular and Vue as well as plain pages. Code Effects looks like part of your application, not a separate product placed inside it.
-
High-Performance IL-Compiled Evaluation
Rules are compiled into IL, becoming part of your application’s execution path rather than being interpreted at runtime. This eliminates interpretation overhead and enables low-latency, high-throughput evaluation. In benchmark scenarios, the engine has demonstrated the ability to evaluate ONE MILLION object instances against a simple rule in less than 10 milliseconds. Rules from the Rule Repository and rules recorded by Audit are compiled the same way and run at the same speed.
-
Stateless and Thread-Safe Runtime
The engine is built as a thread-safe library, enabling safe and efficient execution in multithreaded and concurrent environments. Rules are compiled once and can be evaluated across multiple threads without contention or shared-state issues. This makes it suitable for mission-critical systems that require reliability, scalability, and predictable behavior under load.
-
Rule-Based Data Filtering
A single evaluation rule can be used to filter in-memory collections of .NET objects using LINQ to Objects. This enables the same rule definition to drive both decisions and object filtering. By reusing business rules as filter logic, applications can implement dynamic search, segmentation, and data selection without duplicating logic across layers.
-
Native Visual Studio Debugging
Debug business rules directly within Visual Studio using a tracing delegate passed to the Evaluate method. Set breakpoints, step through execution, and inspect condition-level results alongside your source data in real time. The same delegate can log every evaluation in production, bringing native debugging and full transparency to business rules for the first time.
-
Compile for Any Platform
Built on .NET Standard 2.0, the Rule Engine and the Rule Editor run on any modern .NET runtime, from .NET Framework 4.6.2 to .NET 8 and later, on Windows, Linux and macOS, in containers and in the cloud. With the Code Effects Source package, teams can compile the platform for their own target environments, enabling consistent deployment across desktop, server, iOS and Android without changes to rule logic. The entire Code Effects platform is coming to Java in 2027.
-
Self-Contained Data Processing
All rule evaluation runs locally with no required outbound calls or access to external systems. Rules, data and user context remain within your environment by default, and in version 7 the Rule Repository and Audit keep rules, versions and decision records in a database you own, on your own hardware. The only data that leaves is what the optional AI features send to the AI provider you configure. This architecture supports secure, compliant deployments, including isolated or air-gapped systems. This unique capability consistently drives adoption of Code Effects in mission-critical, high-visibility projects more than all other features on this page combined.
-
Enforced Rule Execution Security
The engine supports a whitelist of trusted assemblies allowed to declare in-rule methods and rule actions. When defined, this list is enforced during rule evaluation, and an exception is thrown if a rule attempts to invoke methods outside of the approved namespaces. This prevents unauthorized or potentially malicious code from being executed during rule evaluation, whether a person, a script or an AI agent wrote the rule.
-
Built for Strict Application Security
The browser components are designed for demanding security environments. 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. Every Rule Repository request carries an anti-forgery token and is checked against configurable limits on request sizes and counts.
-
Licensing That Fits Every Use
The Rule Engine and the Rule Editor are free for personal, community, development and research use as Code Effects Personal, with no limits on users, evaluations, developer seats or hardware, and are available to everyone on NuGet. Commercial use requires a perpetual Code Effects package: Standard for the Rule Engine and the Rule Editor; Business, Enterprise or Ultimate to add the Rule Repository, Audit and the MCP server, licensed per team of 30 users; and Code Effects Source for the source code of the entire platform. There are no per-evaluation or usage fees. See Code Effects Packages.