Code Effects vs DecisionRules
Short Answer
Code Effects and DecisionRules can solve the same class of problems - for example, using an LLM to convert unstructured documents into structured data a rules engine can evaluate - but they approach them from opposite architectural starting points.
DecisionRules is an external service - SaaS on AWS, a private managed cloud, or a self-hosted instance you run in Docker or Kubernetes. Whichever you choose, it is a separate platform your application calls over the network. It has no access to your codebase, so every piece of the AI pipeline - the input/output model, the prompt, the field-by-field extraction instructions, any reference documents, the error-handling paths - has to be collected as data inside its platform and reassembled on every evaluation. That's why building an AI Agent rule in DecisionRules means designing an output model, writing a structured prompt, annotating every output field with its own "mini-prompt," wiring a multi-node Decision Flow (AI node → parallel Decision Trees → error-handling nodes → Switch → Assign), and maintaining all of it inside their visual editor. Its AI Assistant can now draft much of that structure from a description, but the result is the same set of platform artifacts to review and maintain.
Code Effects is an embedded .NET decision management platform. Its Rule Engine runs inside your own application and can invoke any public method on your own objects during rule evaluation. That means the LLM call, the document schema, and the extraction logic live where they belong - in your codebase, written once by your developers - while the rule itself only carries the parts that are genuinely business logic: thresholds, allow-lists, and routing decisions. Code Effects 7 adds the rest of the decision lifecycle around that rule, still inside your own application: an optional Rule Repository with immutable versions, a decision workflow of approvals and Go Live, and tests on your real classes; Audit for decision explainability of every production evaluation; an AI Rule Editor and an AI Assistant that can read your PDF policy documents; and an MCP server for external AI agents - all under your own sign-in, against a database you own.
Choose DecisionRules if you have no in-house development capacity, want a vendor-managed platform with its own compliance certifications, and are willing to have your business team take on real schema-design and prompt-engineering work. DecisionRules markets its AI Agent rule builder as no-code, but designing an output model, choosing the correct data type per field, and writing field-level annotations precisely enough to drive consistent extraction is programming in every sense except syntax - and unlike a compiler, the platform can't tell whether an annotation says what you meant. A wrong type selection or a misaligned annotation doesn't necessarily throw an error; as far as we found, it can produce a rule that looks complete and fails quietly at evaluation time.
Choose Code Effects if you have a development team and want the AI/document-processing complexity encapsulated in code you own, while giving business users a rule-authoring surface where every option they can select - and every rule an AI writes for them - is guaranteed to be structurally valid and executable: no schema typing, no type mismatches, and no AI-written change reaching production without a person's approval.
One rule, one readable text - even in an AI conversation. A Code Effects rule, however complex, is a single document that reads as plain language, so when the Rule Repository's AI writes or changes a rule, the whole rule appears in the conversation, already checked against your source object, for the person to read and judge before anyone saves it. In DecisionRules, logic of the same complexity becomes several tables, scripts and flows, and its AI Assistant offers summaries, plans and imports rather than the logic itself in readable form. See Reviewing What the AI Wrote.
There's a deeper version of this argument worth stating plainly: neither vendor will ever have a pre-built LLM orchestration for a genuinely specific, long-tail need - extracting particular regulated values from a specific type of German government document required only in certain German industries, for instance. That work gets built by the customer either way. The real question isn't whether the customer builds it - it's whether the result plugs directly into the rules engine, or has to be reshaped first to satisfy a vendor's execution environment. See Long-tail orchestration below for details.
Why the Architectures Diverge
|
DecisionRules |
Code Effects |
| Deployment model |
External service - public cloud SaaS on AWS (US and EU regions, with region-locked US, EU and Australia options), private managed cloud, or self-hosted with Docker or Kubernetes - called over the network |
Embedded libraries that run in-process inside your own application; the optional Rule Repository, Audit and MCP server run inside your own web application, against your own SQL Server or PostgreSQL database |
| Platform |
Any language that can call its REST APIs |
.NET Standard 2.0 (.NET Framework 4.6.2+, .NET Core 2.0+, .NET 8+) on Windows, Linux and macOS; the Rule Repository and Audit run in ASP.NET Core or ASP.NET on .NET Framework 4.7.2+, and the MCP server on .NET 8+; the entire platform is planned for Java in 2027 |
| Access to your code |
None - must externalize everything as data |
Full - can invoke any public method at evaluation time |
| Where the JSON schema lives |
Authored inside the DecisionRules UI (input and output models, visual or JSON editor) |
Anywhere you choose - whether defined in your C# class, passed to the rule evaluation as a field value, or provided as a parameter to a rule action. |
| Where the prompt lives |
Authored inside the DecisionRules UI, with {placeholder} substitution; reference documents attached to the rule |
Inside your own action method implementation - any LLM, local or hosted, or no LLM at all |
| Field-level extraction guidance |
"Annotations" - per-field description text acting as mini-prompts, authored per rule |
Handled once in code - either with C# attributes or by assigning metadata field properties dynamically; not re-authored in every rule. |
| Error/timeout handling |
Modeled explicitly as flow nodes (Assign, Append, Switch) per rule |
Handled in your action method's own code, written once and reused |
| What the business user actually authors |
The schema, the prompt, the annotations, and the Decision Trees for thresholds |
Only the business parameters - thresholds, allow-lists, booleans, routing - passed as parameters to existing actions |
| Rule composition / reuse |
Achieved via separate Decision Trees wired into a Decision Flow |
Achieved with reusable rules and inline rules (Execute... in THEN/ELSE), or by firing other rules from a custom action method, at the rule author's discretion; the Rule Repository prevents changes that would create a circular dependency or break a calling rule |
| Re-evaluation on mutated state |
The service re-triggers the flow as document status changes - its only option, since it can't loop internally |
The team decides: loop inside the action method, re-fire the rule, or check status outside the rule entirely |
| LLM choice |
Per AI Agent rule, a model and an authenticated connector to its provider; the AI Assistant runs on Google Gemini, according to DecisionRules' FAQ, and self-managed deployments can connect their own AI credentials |
Any LLM, including self-hosted/local models - nothing leaves your infrastructure unless your code sends it out (or, if you turn them on, the Rule Repository's AI features send their work to the model your application registers) |
| Setup surface for one document-review process |
I/O model + prompt + annotations + 4+ Decision Trees + 3-4 flow nodes |
One rule, one action method |
| Versions and approvals |
Numbered rule versions, Pending until Published, with rule history and side-by-side comparison on selected subscriptions; we found no built-in approval workflow - DecisionRules' own article describes approvals through a Jira integration |
Rule Repository: immutable versions tied to source versions, drafts, and a decision workflow (request approval, approve or decline, Go Live, Take Offline) with typed confirmations and at most one live version per rule; your application decides who may take each step through 37 permissions |
| Testing before production |
Test Bench, rule tests, and AI-generated test data and test suites |
Tests on your real classes: exploration and expectation tests, the decision path for every run, saved tests, value templates, substitute test methods for operations that must not run during a test, and batch runs of up to 350 |
| Explaining production decisions |
Audit logs with inputs, outputs and debug traces, and an optional Explainable AI output for AI Agent rules, according to DecisionRules' materials |
Audit records each production evaluation - rule and source versions, values read, branch taken, actions - for step-by-step replay, explanation, production statistics, and new tests built from real data |
| AI-assisted authoring |
AI Assistant creates Decision Tables, Scripting Rules, Lookup Tables, Decision Flows and complete processes from natural language or an uploaded document |
AI Rule Editor writes a complete rule from instructions in any language; the AI Assistant works across rules, tests, recorded decisions, activity and uploaded PDF policy documents; Adaptive Source scopes the standard editor's menus step by step |
| Reviewing AI-written logic |
The AI Assistant presents progress, a summary or an editable plan for review; each generated table, script or flow is created on import and opened in its own editor; a request that needs several rules becomes a process of rules connected by Decision Flows, according to DecisionRules' documentation |
The complete rule appears in the conversation as one plain-language text, with the server's verdict (Valid, Unfinished or Invalid) and each problem found, however complex the rule - collections, method calls, IF / ELSE IF / ELSE with actions |
| External AI agents (MCP) |
Hosted MCP server with more than 60 actions, scoped to one Space; "nothing publishes without you," according to DecisionRules |
MCP server in your own ASP.NET Core application, on your own OAuth: agents find, explain, write and test rules; every agent save requests approval, and agents can never approve, go live, take offline or delete |
| Guarantee of structural/type validity at authoring time |
The AI Assistant validates generated tables and flows before import; for the AI Agent rule's prompt, output model and annotations, we found no equivalent check in DecisionRules' documentation - as far as we found, a mistyped attribute name, a wrong data-type choice (Text vs Number vs Boolean), or a misaligned annotation can pass through and fail at evaluation, sometimes breaking downstream Decision Flow nodes |
Enforced by the editor itself (Filter, Max/Min, ValueInputType, and other field-level guardrails) and checked again on the server against the source object; invalid elements are blocked before a rule can be saved - every persisted rule is structurally valid by construction, whether a person or an AI wrote it |
| Real skill required from "no-code" authors |
Yes - JSON schema design, per-field data-type selection, and multi-node flow wiring, despite no compiled code being written |
No - business users only supply parameter values (thresholds, allow-lists, booleans, routing) into a pre-validated rule structure; no schema or type authoring is exposed to them at all |
| Licensing |
Plan-based, with limits on rules and API consumption per plan, according to DecisionRules' FAQ |
Perpetual licenses with no per-evaluation or usage fees; free for personal, community, development and research use - see Code Effects Packages |
| Compliance certifications |
SOC 2 Type II and ISO 27001 for DecisionRules' own platform |
Determined by your own hosting environment, since there's no Code Effects service in the loop |
Worked Example: NDA Redline Evaluation
Both platforms can implement the same use case described in DecisionRules' online documentation and used in this article as an example of AI-powered document processing: evaluating a new NDA against company standards (confidentiality period, governing law, notice period, reciprocity) and returning the required redlines. The end result is the same; the architecture behind it is not.
In DecisionRules, building this requires: an AI Agent rule with a hand-built input model (nda.text, originatingParty, etc.) and output model (terms and reference objects with 11 child attributes each); a Role/Context/Task prompt with variable placeholders; per-field annotations instructing the model to return verbatim source text for each extracted term; four separate Decision Trees (one per standard) wired into a Decision Flow; an Assign node to catch LLM processing errors; an Append node to collect errors into an array; and a Switch node to route between the success and error paths. All of it - including the output model itself - is authored and maintained inside the DecisionRules UI, because the service has no other way to get that information.
DecisionRules also publishes a shorter NDA Terms Validation template in which a single AI Agent checks the terms against "the company's minimum NDA standards defined in the attached policy document." That removes most of the flow - but it also moves the standards themselves from deterministic Decision Trees into the model's reading of a document, so the pass/fail judgment on each term is made by the LLM.

In Code Effects, the same process is one rule against a Source object exposing an EvaluateDocument() action:

The schema, the prompt, the extraction logic, and the error handling all live inside EvaluateDocument() - written once in C#, by a developer, using any LLM or even custom parsing logic with no LLM at all. The rule itself carries only what a business user should own: the thresholds and the routing decisions after evaluation - and those thresholds are evaluated deterministically by the Rule Engine, not by the model.
Code Effects also supports Prompted rule elements - string fields, parameters, or return values flagged for AI resolution at evaluation time, with the prompt text captured at authoring time but resolved by developer-written code at runtime. This gives teams a lighter-weight middle option for simpler cases - resolving a single value with AI assistance - without building a full custom action method.
Compare the complexity of DecisionRules - a hand-built output model, per-field annotations, an AI Agent node, four parallel Decision Trees, an Append node, a Switch node, and two Assign nodes mapping target/source pairs by hand - to the entire equivalent logic in Code Effects:
One sentence-structured rule, one action method.
The following source object was used to generate the Code Effects UI shown below. It has been simplified for this article but is based on the metadata described in the DecisionRules documentation for the same use case. In both platforms, this type of source object - or its serialized representation - provides the data that is evaluated against the rule at runtime.
using System;
using CodeEffects.Rule.Common.Attributes;
namespace Test;
public class Nda
{
[Field(DisplayName = "Max Confidentiality")]
public int MaxConfidentiality { get; set; } = 0;
[Field(DisplayName = "Acceptable Law")]
public Law AcceptableLaw { get; set; } = Law.Undefined;
public Reason Reason { get; set; } = Reason.Undefined;
[Field(DisplayName = "Reciprocity Must Exist")]
public bool ReciprocityMustExist { get; set; } = false;
[Field(DisplayName = "NDA Status")]
public NdaStatus Status { get; set; } = NdaStatus.Undefined;
[Action(DisplayName = "Evaluate Document")]
public void EvaluateDocument() { /* Evaluation logic goes here */ }
[Action(DisplayName = "Send for Processing")]
public void Process(Nda document) { /* Further processing of the document */ }
public void Log(Nda document, string message) { /* Logging logic goes here */ }
public void Stop() { /* Process finalization logic goes here */ }
[Action(DisplayName = "Notify Legal")]
public void Legal(Nda document, string message) { /* Logging logic goes here */ }
}
public enum NdaStatus
{
[ExcludeFromEvaluation]
Undefined,
[EnumItem("Not Processed")]
NotProcessed,
Failure,
Success
}
public enum Reason
{
[ExcludeFromEvaluation]
Undefined,
[EnumItem("Invalid Document")]
InvalidDocument,
Review
}
public enum Law
{
[ExcludeFromEvaluation]
Undefined,
USA,
Canada
}
With version 7, the rule language gets more compact for cases like this one: a single Acceptable Law is in (USA, Canada) condition replaces a chain of OR'ed comparisons, and is between expresses an inclusive range of years in one statement.
There is no decision automation capability offered by DecisionRules that cannot be implemented with Code Effects. The real difference lies in how each platform approaches the problem - and what that means for your architecture, business users, deployment, and long-term maintenance.
The Same NDA Rule Across Its Whole Lifecycle
The worked example above stops where most comparisons stop: at a rule that evaluates. In production, the NDA standards change, someone has to approve the change, Legal asks why a particular NDA was routed to them, and the written policy and the executable rule drift apart. Code Effects 7 covers that lifecycle inside your own application:
- Versions and approval. In the Rule Repository, every saved change to the NDA rule is an immutable version linked to the version of the
Nda source object it was written against. Raising the maximum confidentiality period is a new version that goes through request approval, approve or decline, and Go Live, each with a typed confirmation, and only one version of the rule is live at a time. Rolling back is making an earlier version live again.
- Testing before Go Live. An expectation test can state that an NDA with a 20-year confidentiality period must reach Legal, and report pass or fail; an exploration test answers what-if questions with the same rule. Because
EvaluateDocument() calls an LLM in production, the source object can name a substitute test method, so tests run the rule without calling the model. Saved tests run in batches of up to 350 every time the rule changes.
- Explaining a production decision. With Audit, each production evaluation is recorded with the rule and source versions, the values read, the branch taken and the actions called. A correlation field, such as a document number, associates evaluations with a particular business case. When Legal asks why an NDA was routed to them, the evaluation can be reviewed and replayed step by step, and turned into a new test using its actual production values.
- Comparing written policy with the rule. An authorized user can upload the company's NDA policy as a PDF into the AI Assistant and ask whether its standards still match the live NDA rule, or ask how many NDAs were routed to Legal last quarter and why. The Assistant shows its steps, keeps conversation history, and reports token usage and cost.
- Changing the rule in plain language. In the AI Rule Editor, a user can write "notify Legal when the governing law is not USA or Canada" in any language. The result is checked against the
Nda source object immediately. The AI Rule Editor never saves anything itself: the user reviews the rule and saves it through the dialog, under their own permissions, and the new version then goes through the same approval and Go Live as any other.
The AI tools work on the rules and their history; they do not replace EvaluateDocument(). The production evaluation of each NDA is still your own code and the Rule Engine, in-process and deterministic.
AI-Assisted Rule Authoring:
Generated Artifacts vs Validated Rules
Separate from the AI Agent rule feature covered above - which uses AI to extract structured data from a document - DecisionRules also offers an AI Assistant for authoring rules themselves. You describe your logic in plain language (for example: "If the customer's age is greater than 18 and their credit score is above 700, then approve the loan"), or start from an uploaded document, and the assistant drafts a Decision Table, a Scripting Rule, a Lookup Table, a Decision Flow, or a complete process of several rules and the flows that connect them. According to its documentation, it asks structured clarification questions when something essential is missing, validates generated tables and flows before they are imported, and can generate test data and test suites whose expected outputs are solved from the saved rule version rather than invented by the AI.
Code Effects now offers two complementary approaches. The Rule Repository's AI Rule Editor also writes a complete rule from one request - against the source object's own members, validated immediately. And in the standard Rule Editor, Adaptive Source supplies the field and method menus one step at a time, scoped to the rule's current context - optionally using AI to decide what's relevant next - while the rule author assembles the rule element by element, in something close to a natural-language sentence.
|
DecisionRules AI Assistant |
Code Effects AI Rule Editor |
Code Effects Adaptive Source |
| What the AI does |
Infers a table, script, flow or complete process - conditions, columns, and values - from a natural-language prompt or document |
Writes or changes a complete rule from instructions in any language, using only the members of the source object |
Optionally decides which fields/methods to surface next, one step at a time, as the rule author builds the rule |
| What the rule author does |
Answers clarifying questions, then reviews and edits the finished draft before import |
Reviews the rule in the standard rule format, edits it directly or keeps instructing the AI, tests it, and requests approval |
Builds the rule element by element, guided by contextual menus |
| Failure mode when the AI gets it wrong |
The generated structure is validated before import, but a table can still look complete while missing an edge case or misreading a condition - the rule author has to catch that in review |
Structurally invalid output is rejected with validation feedback; a structurally valid rule that misreads the intent is caught by tests, review and approval |
Structurally prevented - the editor blocks invalid or out-of-scope elements before they can be added, regardless of what suggested them |
| What happens when an earlier condition changes |
We found no documented mechanism for detecting logic invalidated by an earlier edit |
The whole rule is validated again against its source object on every save |
Context Resetters detect changes to a designated condition and automatically remove now-invalid downstream elements, with one-click Undo |
| Path to production |
Publishing a Pending version |
The AI never saves: the user saves the rule through the dialog, and the new version goes through the Rule Repository's decision workflow; an AI can never approve, go live, take offline or delete |
The Rule Repository's decision workflow, or your own storage in a stand-alone implementation |
| Resulting rule form |
A structured table, script or flow |
A near-natural-language sentence: "If X then Y and Z" |
A near-natural-language sentence: "If X then Y and Z" |
The practical difference: a DecisionRules AI Assistant draft is checked for its own structure, but as far as we found it is a platform artifact checked against itself, which means a human still has to review it for what it actually does with the data before trusting it in production. A Code Effects rule - whether a person built it with AI-assisted menu narrowing or the AI Rule Editor wrote it from one sentence - is validated against the source object your application actually evaluates, so there's no separate structural review pass, because nothing structurally invalid could have been saved to begin with. Whether the rule expresses the intended policy is still checked with tests and approvals, on both platforms.
Honest caveat: neither approach eliminates setup. A developer still has to supply the source object or implement the ISourceProvider first, exactly as DecisionRules needs a team to define the input model its AI Assistant generates against. One-sentence authoring in Code Effects is part of the Rule Repository, which is licensed separately; in a stand-alone implementation, the rule author's experience is genuinely slower step-by-step composition, not an instant finished draft. DecisionRules' AI Assistant also goes further than a single rule: it can draft a whole multi-rule process from a document. (Full mechanics - Adaptive Source, Context Resetters, and the field-level guardrails behind this guarantee - are documented in Code Effects' comparison of AI-assisted rule editors.)
Reviewing What the AI Wrote: The Whole Rule in the Conversation
In Code Effects, a rule is one document. However complex it gets - collections and existence checks, calls to your own .NET methods with their parameters, computed values, mixed AND/OR conditions, and IF / ELSE IF / ELSE branches that each carry their own actions - it is stored as one Rule XML document and reads as one plain-language text, the same text the Rule Editor shows. That is what lets the Rule Repository's AI show its work in full. Every rule the AI Rule Editor or the AI Assistant writes appears in the conversation as a card holding the complete rule as text, headed by the server's verdict - Valid, Unfinished or Invalid - and followed by each problem found against the source object. The person reviews the whole rule where they asked for it, in the words they would have used themselves, and what they read is what goes into the Rule Editor and, once they save it, into the repository.
DecisionRules works from a different unit. According to its documentation, the AI Assistant creates Decision Tables, Lookup Tables, Scripting Rules in JavaScript and Decision Flows that connect rules, and when a request needs several rules and their orchestration, it points to its Process Architect instead of forcing the logic into one table - so a complex decision arrives as several artifacts and the flows between them. What the chat presents is generation progress, a summary, or an editable plan; the rule itself is created when you select Import Rule, which opens it in the editor. DecisionRules' Decision Trees can nest IF and ELSE blocks to any depth inside one rule, but they are a visual tree, and we found no mention of them among the AI Assistant's rule types. As far as we found, nothing in DecisionRules shows a complex decision - its tables, scripts and flows together - as one readable text, in the chat or anywhere else; reviewing it means opening each artifact in its own editor and following the flow between them.
This matters most exactly where AI is most useful: the long, multi-branch rules nobody wants to assemble by hand. The larger the logic, the more a reviewer depends on seeing all of it at once - and the more a summary of it can leave out.
To be precise about the claim: a Code Effects rule that calls a reusable rule or runs an inline rule names it in its text, and that rule is a rule of its own - one more readable sentence, not a table or a flow. And one DecisionRules Scripting Rule can also hold complex logic in a single document, as JavaScript: code for a developer to review, not a sentence for a business owner.
AI Agents and MCP: A Hosted Space vs Your Own Application
Both platforms now let the AI clients people already use work with rules through the Model Context Protocol. According to DecisionRules, its MCP server offers more than 60 actions: agents in ChatGPT, Claude, Copilot, Cursor and other clients can build Decision Tables, Lookup Tables and Scripting Rules from a description, update versions and tags, generate test data, run a rule against real input, compare versions and trace dependencies. Access is scoped to one Space chosen at sign-in, changes go into version history, and DecisionRules states that nothing reaches callers until a version is published; we found no description of how publishing by an agent is prevented.
The Code Effects MCP server runs inside your own ASP.NET Core application and uses your application's own OAuth sign-in, so credentials are handled through authentication rather than passed to individual tools. Agents can inspect sources, rules, tests and recorded evaluations, create and update rules, versions, drafts and tests, and use history for investigation and reporting, under the same permissions as the person they represent. The restrictions are enforced by the platform: every agent save requests approval, agents can never approve, go live, take offline or delete, even if the host grants those permissions by mistake, and tests that would call production code - such as an EvaluateDocument() that calls an LLM - require confirmation from the person using the agent. The MCP server works with the Rule Repository, Audit, or both, and the built-in AI Assistant and AI Rule Editor do not need it.
Long-Tail Orchestration: Where Does Custom AI Work Actually Live?
Both platforms will encounter customer needs neither vendor built for - a document-extraction pipeline for a niche regulated document type, a multi-step validation flow specific to one industry, a normalization step that only makes sense given data the customer already has elsewhere. Once you accept that the vendor is extremely unlikely to ship that exact orchestration, the customer builds it regardless of which platform they chose. The comparison that matters, then, isn't "build vs. don't build" - it's what the customer's already-working pipeline has to go through to be usable inside each platform.
In DecisionRules, custom logic has two routes in, and both add a layer of vendor-shaped adaptation on top of the customer's own work:
- The AI Agent rule path (covered above) requires the orchestration to be re-expressed as data - a prompt, an output model, per-field annotations, and any attached reference documents - authored and versioned inside DecisionRules' UI, sent to the model through a connector.
- The Scripting Rule path allows custom JavaScript, but it runs inside DecisionRules' own execution environment: according to its documentation, cross-rule calls go through its own
DR class rather than native code. A team that already has a working extraction pipeline - a Python service, an internal document-processing tool, an existing Bedrock or Azure AI integration - cannot simply call it as-is; it has to be re-implemented, in JavaScript, inside DecisionRules' sandbox, subject to whatever execution limits that environment imposes.
Either route means the customer's orchestration is built at least twice in effect: once to do the actual work correctly, and again reshaped to satisfy the vendor's schema, sandbox, or calling convention.
In Code Effects, EvaluateDocument() - or any custom action method - is ordinary, native C# running in-process. There is no sandbox to adapt to, no JSON contract to satisfy, no platform-specific calling convention. Whatever pipeline the customer already has working - in Python, in an internal service, calling any LLM provider or none at all - plugs in as a method call. Nothing about the platform shapes how that orchestration is written.
|
DecisionRules |
Code Effects |
| Where custom orchestration executes |
Inside DecisionRules' own execution context - the AI Agent rule's connector-managed call, or the Scripting Rule sandbox |
Inside your own process, as native .NET code, with no platform-imposed sandbox |
| Adaptation required before reuse |
Existing pipelines must be re-expressed as prompt/model/annotations, or reimplemented in platform-side JavaScript |
None - an existing method, service call, or library reference is used directly |
| Network/protocol surface to satisfy |
Orchestration must be reachable by, or authored inside, DecisionRules' platform (cloud or self-hosted instance) |
None beyond whatever your own code already calls |
| What changes when the orchestration logic changes |
The platform-side model, prompt, annotations, attachments, or platform-side script - a second place to update, in addition to any logic that lives outside the platform |
A single code change in your own method, deployed through your own existing pipeline |
| Compliance surface per orchestration change |
Must satisfy both your own requirements and the assumptions built into DecisionRules' schema/sandbox model |
Only your own requirements apply - there is no intermediate platform contract to satisfy |
The question was never really which LLM provider is available. It's which vendor-owned artifacts - a schema, a sandbox, a connector, a calling convention - the customer's own orchestration has to be reshaped to satisfy before it can run.
DecisionRules requires an answer to that question. Code Effects doesn't, because there's no vendor-owned execution environment standing between the customer's code and the rule.
Honest tradeoffs
DecisionRules' case: if you have no development capacity at all, DecisionRules gives your business team a path to build the entire pipeline without compiling code, and on its managed cloud you're not responsible for hosting, uptime, or the AI integration itself. Its AI Assistant can now draft whole multi-rule processes from a description or a document, its AI Agent rule can attach reference documents and return an explanation with each AI result, it offers a hosted MCP server, and its platform carries SOC 2 Type II and ISO 27001 certifications. The multi-node Decision Flow does make every step of the process visible in a diagram, which some teams may value for auditability. But "no-code" undersells what's actually required to build it correctly: designing an I/O model, choosing the right data type per field, and writing per-field annotations precise enough to get consistent extraction is real, unforgiving work - and the platform provides no equivalent to a compiler's error-checking for whether an annotation means what its author intended. A wrong type or a misaligned annotation doesn't always fail loudly; as far as we found, it can produce a rule that looks finished and breaks downstream, in exactly the way a subtle programming bug would.
Code Effects' case: the "one simple rule" only stays simple if EvaluateDocument() is well-engineered, and someone with development skills still has to build it, along with exposing the source object - Code Effects doesn't eliminate that setup work any more than DecisionRules eliminates the need for a team to define the input model its AI features generate against. It is also a .NET platform today, with Java planned for 2027, and its versions, approvals, tests, Audit and AI tools come with the optional Rule Repository, licensed separately and hosted by your own ASP.NET application and database - typically 3 to 4 days of work for one developer, plus 1 to 2 days of testing (see Code Effects Implementation). What differs is what happens on the business user's side of that boundary. In Code Effects, the rule editor and the server enforce field-, method-, and parameter-level constraints before a rule can be saved, so every option a business user can select - and every rule an AI writes - is guaranteed to produce a structurally valid, immediately executable rule, with no human structural check required. Tests and the Rule Repository's decision workflow remain the place to confirm that a rule expresses the intended policy, and no AI can take a rule past that workflow. In DecisionRules' AI Agent rule builder, the business user is typing attribute names and picking types themselves, with no such safety net. (See Code Effects' comparison of AI-assisted rule editors for the underlying guardrail mechanisms - Filter, Max/Min, ValueInputType, and Context Resetters - that make this guarantee possible.)
FAQ
Is Code Effects a replacement for DecisionRules?
Not directly - they're architecturally different products. DecisionRules is an external service (SaaS, private managed cloud, or self-hosted with Docker or Kubernetes) with a visual rule/flow builder; Code Effects is an embedded .NET decision management platform that runs inside your own application, with an optional Rule Repository, Audit and MCP server in your own web application. Code Effects runs on .NET today, and the entire platform is planned for Java in 2027. Teams choose between them based on whether they have in-house development capacity, not just on rules-engine feature lists.
Why does DecisionRules require building a JSON schema and prompt inside its UI?
Because it's a separate service with no access to your codebase, DecisionRules has no way to run your own extraction code. Everything the LLM needs - output model, prompt, field-level instructions, reference documents - has to be defined as data inside its platform and sent along with each evaluation request.
Does Code Effects call an LLM automatically?
Not during rule evaluation. Code Effects doesn't include built-in LLM/document-processing logic in the Rule Engine. It invokes whatever public method your rule references - such as a custom EvaluateDocument() action - and your code decides which LLM (hosted or self-hosted) or parsing approach to use, if any. The Rule Repository's AI Assistant and AI Rule Editor, new in version 7, use the models your application registers, with your own API keys, to help people write, test and investigate rules; they are not part of evaluation.
Can business users still configure AI-assisted rules in Code Effects without a developer?
Business users can supply the values that are genuinely business logic - thresholds, allow-lists, required clauses, routing outcomes - as parameters in the THEN clause of a rule, and in the Rule Repository they can describe a change in plain language to the AI Rule Editor. Defining the underlying schema, prompt, or extraction logic requires a developer to implement or update the action method, similar to how DecisionRules requires someone with prompt-engineering knowledge to build its AI Agent rule properly, despite being marketed as no-code.
Does Code Effects have rule versions and approvals like DecisionRules?
Yes, with the optional Rule Repository in version 7: immutable rule versions tied to source versions, comparisons, drafts, tests on your real classes, and a decision workflow (request approval, approve or decline, Go Live, Take Offline) with typed confirmations and at most one live version per rule. DecisionRules versions are Pending until Published; we found no built-in approval workflow in its documentation, and its own article describes approvals through a Jira integration.
Can Code Effects explain why a particular NDA was routed to Legal?
Yes, with Audit in version 7. It records each production evaluation - the rule and source versions, the values read, the branch taken and the actions called - and the Rule Repository replays any recorded decision step by step, explains it, and can turn it into a test using the actual production values.
Do both platforms support AI agents through MCP?
Yes. According to DecisionRules, its hosted MCP server lets agents create, version, test and run rules within one Space, and nothing reaches callers until a version is published. The Code Effects MCP server runs in your own ASP.NET Core application on your own OAuth sign-in; agents can find, explain, write and test rules and investigate recorded decisions, every agent save requests approval, and agents can never approve, go live, take offline or delete, even if granted those permissions by mistake.
Can a Code Effects rule re-evaluate itself after mutating an object's state?
Yes. A rule can fire repeatedly against the same object as its state changes - for example, after EvaluateDocument() updates a document's status - with the team deciding whether that looping happens inside the action method, through repeated rule evaluation, or via an external status check. DecisionRules' flow re-triggers similarly, but as an external service it has no alternative implementation option.
Does Code Effects support reusing the same validation logic across multiple rules or processes?
Yes, via reusable and inline rules, or via custom action methods that fire other rules, at the rule author's discretion; the Rule Repository prevents changes that would create a circular dependency or break a calling rule. DecisionRules achieves similar reuse by wiring separate Decision Trees into a Decision Flow, which is useful when the visual flow itself needs to be shared or audited as a diagram.
Does Code Effects support self-hosted LLMs?
Yes - because the AI call happens inside your own action method, you can point it at any LLM, including local or self-hosted models, without your document data leaving your infrastructure unless your own code sends it externally.
Is DecisionRules' AI Agent rule builder actually no-code?
Not in the sense the label implies. No one writes compiled code, but building an AI Agent rule requires designing an input/output model by hand, choosing the correct data type for every field, and writing field-level annotations precise enough to get consistent extraction from the model. As far as we found, errors here - a wrong type, a mistyped attribute name, a misaligned annotation - aren't caught by the platform; they can produce a rule that appears complete and fails at evaluation time. Code Effects' rule editor and server, by contrast, enforce structural and type validity before a rule can be saved, whoever or whatever wrote it.
How does DecisionRules' AI Assistant differ from Code Effects' AI Rule Editor and Adaptive Source?
DecisionRules' AI Assistant drafts tables, scripts, flows or whole processes from a prompt or document, validates their structure before import, and leaves the rule author to review them for correctness. Code Effects' AI Rule Editor also writes a complete rule from one request, but only from the members of the source object your application evaluates; every rule it writes is validated against that source object, and it never saves anything itself - the user saves the rule, and the new version goes through the Rule Repository's approval and Go Live like any other. Adaptive Source, in the standard editor, supplies contextually scoped menus one step at a time as the rule author builds the rule, validating each element as it's added.
Can the AI show the whole rule it wrote, right in the conversation?
In Code Effects, yes. A rule of any complexity - collections, method calls, IF / ELSE IF / ELSE with actions - is one document that reads as plain language, so the Rule Repository's AI shows the complete rule in the conversation, with the server's verdict against the source object. According to DecisionRules' documentation, its AI Assistant presents a summary or plan for review, a complex request becomes several rules connected by Decision Flows, and each generated rule is reviewed in its own editor after import.
If neither vendor has a pre-built orchestration for our specific use case, does that make Code Effects and DecisionRules equally easy to use?
No. Both require the customer to build the orchestration themselves, but what happens next differs. In DecisionRules, that custom logic must be re-expressed as a prompt, model and annotations for an AI Agent rule, or reimplemented inside the Scripting Rule environment - either way, adapted to fit the platform's execution model. In Code Effects, the same custom logic runs as ordinary native code in your own process, called directly from the rule with no schema, sandbox, or protocol layer to satisfy first.