NormCode Canvas: Making LLM Agentic Workflows Development Sustainable via Case-Based Reasoning

1. Problem Statement

Multi-step Large Language Model (LLM) workflows have become the standard for deploying agents in real-world applications. However, current orchestration frameworks (e.g., LangChain, LangGraph, AutoGen) suffer from critical limitations regarding debuggability, reproducibility, and systematic improvement:

• Implicit Shared State: Intermediate checkpoints often rely on accumulated conversation history or mutable objects rather than self-contained data. This makes it difficult to isolate the cause of failures (non-localizable failures).
• Brittle Recovery: Resuming a workflow from a checkpoint often fails because the context required for the next step is not explicitly captured in the saved state.
• Lack of Structural Isolation: The plan, its semantics, and execution conditions are scattered across code and prompts, preventing reliable retrieval and reuse of past execution states (Cases).
• Inability to Iterate: Improving a workflow often requires reconstructing large portions of prior execution rather than targeted revision of specific steps.

The paper argues that a workflow language is needed where reasoning is explicitly represented, structurally enforced, and self-contained to enable Case-Based Reasoning (CBR) at scale.

2. Methodology: NormCode and Two-Level CBR

The authors propose NormCode, a semi-formal planning language, and NormCode Canvas, a deployed system that implements a Two-Level Case-Based Reasoning (CBR) architecture.

A. The NormCode Language

NormCode is designed to enforce Structural Isolation via a Scope Rule.

• Scope Rule: Every execution step can only access data explicitly declared in its immediate scope block. There is no implicit sharing of context from previous steps.
• Three Forms:
  1. .ncds (Source): Human-authored, semi-formal, natural-language-based syntax.
  2. .ncd (Compiled): Rigorously formalized, machine-executable plan.
  3. .ncn (Narrative): A deterministic, plain-prose rendering of the plan for pre-execution human review.
• Key Properties: Interpretable, Enforceable (compiler-verified), Composable, Locally Addressable (via flow indices), Generalizable, and Portable.

B. Two-Level CBR Architecture

The system treats workflows as cases at two distinct levels:

Level 1: Concrete Case Management (Suspended Runtimes)

• Definition: A Level 1 case is a snapshot of the execution environment at a specific flow index (checkpoint). It includes the Blackboard state (node status) and the Concept Repository (data tensors).
• Mechanism:
  • Retrieve: Users can inspect any checkpoint directly. Because of the scope rule, inputs are bounded and self-contained.
  • Reuse (Fork): A user can fork a run from any checkpoint. The system loads the state and resumes execution from the next pending node without re-executing upstream steps.
  • Revise (Value Override): Users can edit specific data tensors at a checkpoint. The system automatically marks all downstream nodes as "stale" and re-executes only those dependent nodes (Selective Re-execution).
  • Retain: Every completed node automatically writes a new case to the database.

Level 2: Abstract Case Learning (Executable Plans)

• Definition: A Level 2 case is the workflow plan itself (the .ncds source and its compiled repositories). It represents a reusable solution pattern for a class of problems.
• Mechanism:
  • Compile Pipeline: The process of converting natural language specifications into executable NormCode plans is itself a Level 2 case (NC Compilations).
  • Recursive Learning: The compilation pipeline can be revised and improved just like any other workflow, creating a recursive loop where the system improves its own ability to generate plans.

3. Key Contributions

1. Two-Level CBR Framework: A novel architecture distinguishing between concrete cases (suspended runtimes for debugging/reuse) and abstract cases (executable plans for pattern reuse), enabling cumulative learning at the system scale.
2. NormCode Workflow Language: A language satisfying six properties (Interpretable, Enforceable, etc.) that guarantees Structural Isolation. This ensures every checkpoint is a genuinely self-contained case, eliminating implicit state dependencies.
3. Three Structural Capabilities (C1–C3):
   • C1 (Direct Checkpoint Inspection): Exact bounded inputs are inspectable without log reconstruction.
   • C2 (Pre-execution Review): A deterministic narrative (.ncn) allows human experts to verify plan logic before any LLM call.
   • C3 (Scope-Bounded Selective Re-execution): Revisions trigger re-execution only for downstream dependent nodes, ensuring efficient debugging.
4. Deployed System (NormCode Canvas v1.1.3): A fully functional system integrating a graph-based visualizer, a detail panel for tensor inspection, and a SQLite-based case store.

4. Results and Case Studies

The authors validate the system using four deployed production workflows, demonstrating that the structural properties hold across different control-flow patterns:

1. PPT Generation: A nested dual-output loop (HTML + PPTX) generating slides at ~40s per slide. Demonstrates Level 2 Reuse (the plan is reused for different topics) and Level 1 Accumulation (each slide is a checkpoint).
2. Code Assistant: A ReAct-loop workflow for software engineering (Explore, Plan, Implement, Verify). It handles up to 10 reasoning cycles. Demonstrates Selective Re-execution (fixing a planning step only re-runs implementation/verification).
3. NC Compilations: A self-hosted compiler that converts natural language specs into executable NormCode plans. Demonstrates Recursive Retention (the compiler is a plan that can be improved by the system).
4. Canvas Assistant: An interactive controller that connects to external AI code editors (e.g., Cursor) to automate plan debugging.

Performance Metrics:

• Syntactic Efficiency: 60–70% of nodes in production plans are syntactic (deterministic data manipulation) rather than semantic (LLM calls), significantly reducing cost and latency.
• Scalability: The system successfully manages complex, multi-step workflows with up to 30–40 inferences per run.

5. Significance and Impact

• Shift from "Black Box" to "Auditable": NormCode moves LLM workflow development from opaque, state-heavy execution to a transparent, structurally isolated model where every step is addressable and revisable.
• Sustainable Improvement: By treating both execution states and workflow patterns as cases, the system enables cumulative learning. The ecosystem is self-sustaining: plans produce data, data refines plans, and the compiler improves itself.
• Reliability: The Scope Rule solves the fundamental issue of "non-localizable failures" in current frameworks, making agent workflows robust enough for production deployment.
• Human-in-the-Loop: The system prioritizes human oversight via pre-execution narrative review (C2), ensuring that structural logic is verified before costly LLM inference occurs.

In conclusion, NormCode Canvas provides a foundational infrastructure for building auditable, debuggable, and self-improving LLM agent ecosystems, addressing the critical gap between experimental agent prototypes and sustainable industrial applications.