NormCode: A Semi-Formal Language for Auditable AI Planning

1.1 The Problem: Opaque Workflows and Unauditable Reasoning

• Implicit context accumulation and data flow make existing multi-step LLM workflows difficult to audit, debug, and keep consistent.Context pollution can cause hallucinations, forgotten constraints, and compounded errors, while existing orchestration leaves inputs implicit.Source: §1.1 · pp. 1–2

1.2 The Solution: Auditability Through Enforced Data Isolation

• NormCode isolates each inference so it can access only explicitly passed inputs, preventing later steps from accidentally accessing earlier raw data.This language-level rule makes data boundaries explicit rather than relying on workflow conventions.Source: §1.2 · p. 2
• Separating semantic LLM operations from deterministic syntactic data flow enables input, process, and output auditability.Auditors can inspect declared inputs, distinguish probabilistic inference from mechanical restructuring, and examine every intermediate result.Source: §1.2 · p. 2, §1.3 · p. 2

1.3 Contributions

• NormCode contributes an auditable intermediate representation with explicit data flow, multiple stakeholder-facing formats, and a four-phase compilation pipeline.The pipeline progressively transforms natural-language intent into executable repositories with review opportunities at each phase.Source: §1.3 · p. 2
• The implementation includes dependency scheduling, checkpointing, loop management, and a visual debugger for graph inspection and breakpoint debugging.The demonstrations report 100% accuracy on base-X addition and self-hosted execution of the compiler pipeline.Source: §1.3 · p. 2

2.1 Classical Planning and Structured Task Decomposition

• NormCode inherits hierarchical decomposition from classical planning while extending it to probabilistic LLM reasoning within structured subinferences.HTN planning provides a relevant decomposition model, but traditionally operates with symbolic domains and deterministic actions.Source: §2.1 · p. 3

2.2 Modern LLM-Based Agent Frameworks

• Existing agent frameworks support iterative reasoning and orchestration, but their data flow and hidden memory remain difficult to audit.NormCode differs from graph-visible systems such as LangGraph by explicitly declaring every step’s inputs.Source: §2.2 · p. 3

2.3 Intermediate Representations and Structured Reasoning

• NormCode functions as an intermediate representation that is human-authored, machine-executable, and inspectable as a computation graph.It combines structured reasoning with executable and reviewable representations rather than relying on free-form reasoning traces alone.Source: §2.3 · p. 3
• Progressive formalization lets plans evolve from rough sketches, contrasting with rigid fully formal representations and unenforceable free-form Chain-of-Thought.The approach separates functional decomposition from syntax while retaining enforceable structure.Source: §2.3 · p. 4

2.4 Semi-Formal Languages and the Formalization Spectrum

• NormCode occupies a middle ground: it is structured enough for compilation and execution while remaining accessible through near-natural-language authoring and narratives.This balances natural language’s expressiveness against the rigidity of fully formal languages.Source: §2.4 · p. 4

3.1 Core Syntax: The Inference Structure

• A NormCode plan is a hierarchy of inferences whose functional, value, and context concepts encode operations, data, and carried state.Inference structure makes dependencies explicit and supports bottom-up resolution.Source: §3 · p. 4, §3.1 · p. 4

3.2 The Multi-Format Ecosystem

• The ecosystem provides authoring, formal, natural-language, hybrid, and executable representations for different users and lifecycle stages.Plans move from .ncds through .ncd/.ncn and .nci.json into separated executable repositories.Source: §3.2 · pp. 4–5

3.3 Semantic Concept Types

• Semantic concept types distinguish data entities from functional operations, and only functional concepts invoke LLM calls.Other concepts support data-structure manipulation rather than AI reasoning.Source: §3.3 · p. 5

3.4 Syntactic Operators

• Syntactic operators reshape, combine, gate, sequence, and iterate references deterministically without examining their content.This makes structural operations free, deterministic, and auditable, with modifiers specifying sources, targets, axes, carries, indices, and new axes.Source: §3.4 · pp. 5–6

3.5 Plan Addressability

• Unique hierarchical Flow Indices provide stable addresses for debugging, intervention, input inspection, dependency references, and checkpoint resumption.Indices are generated during formalization and persist through execution.Source: §3.5 · p. 6

3.6 Semi-Formality: Balancing Structure and Flexibility

• Progressive formalization preserves conceptual content while imposing strict syntax only where compilation requires identities, dependencies, and execution interpretations.This supports rough sketches and refinement without the brittleness of fully formal specifications, while structurally enforcing the rule that steps see only explicit inputs.Source: §3.6 · p. 6

4 The Reference System

• Every data item is encapsulated in a tensor-inspired Reference that can represent anything from a file path to a collection of queries.References provide the machinery for storing and manipulating concept content.Source: §4 · p. 6

4.2 Perceptual Signs: The “Lazy Evaluation” of AI

• Perceptual Signs represent large payloads as lightweight pointers, preventing unnecessary data loading and context pollution across plan steps.The actual object is loaded only when an inference operates on it.Source: §4.2 · p. 6
• A sign encodes a norm, identifier, and signifier, such as a file-location pointer for data/contract.pdf.The file is transmuted only when the relevant inference requires its contents.Source: §4.2 · p. 6

4.3 Semantic vs. Syntactic Operations on References

• Syntactic operations reshape or combine reference structures without inspecting content, making them deterministic and token-free.Examples include slicing, appending, cross-products, and joins.Source: §4.3 · pp. 6–7
• The cross_action operation applies an LLM-prepared function element-by-element, serving as the bridge from structured references to semantic interpretation.Restricting LLMs to cross_action keeps reasoning limited to places where it is necessary.Source: §4.3 · p. 7

5.1 Dual-Readability: Bridging Human and Machine

• NormCode addresses the tension between human-readable natural language and machine-executable precision through four views of the same plan.NCDS supports authoring, NCD execution, NCN verification, and NCDN hybrid editing.Source: §5.1 · p. 7
• The formats preserve one plan at different levels of explicitness, allowing domain experts to audit workflows before execution without losing information.Compilation enriches NCDS with types, bindings, and flow indices, while NCN presents the logic as readable prose.Source: §5.1 · p. 7

5.2 Progressive Formalization: From Sketch to Structure

• Progressive Formalization lets plans evolve from loose NCDS sketches through refinement into rigorous, auditable production workflows.Authors can add type constraints, fix value orderings, and make concepts explicit as failures reveal what needs tightening.Source: §5.2 · p. 7
• Unique flow indices support intervention by letting users pause before steps, inspect inputs, modify references, or fork executions.The Canvas App provides visual tools for these interventions.Source: §5.2 · p. 7

5.3 Semantic vs. Syntactic Separation: Cost and Reliability Tracing

• Semantic operations invoke costly, non-deterministic LLM reasoning, whereas syntactic operations deterministically route data without LLM calls.Most plan steps are syntactic, while imperatives and judgements perform the thinking work.Source: §5.3 · p. 7
• This separation provides cost visibility, reliability localization, and reports distinguishing LLM calls from deterministic data routing.Optimization can target token-consuming steps, while failures are localized to semantic operations.Source: §5.3 · pp. 7–8

5.4 When to Use NormCode

• NormCode is best suited to complex, auditable, resumable, or collaborative workflows, not simple Q&A, rapid prototypes, or latency-sensitive applications.Its structured planning overhead can exceed its benefits when workflows use only one or two LLM calls.Source: §5.4 · p. 8

6.1 The Orchestrator

• The orchestrator schedules dependency-ready inferences, tracks execution state, and updates repositories while isolating failures across unrelated branches.Its Waitlist orders work by flow index, the Blackboard records statuses, and dependency checks gate execution.Source: §6 · p. 8, §6.1 · p. 8

6.2 Persistence and Checkpointing

• SQLite-backed checkpoints save complete execution snapshots under unique Run IDs, supporting patch, overwrite, fill-gaps, resume, and fork workflows.Forking creates a new run history for experiments, retries, or alternative configurations.Source: §6.2 · p. 8

6.3 Agents and the AgentFrame

• AgentFrames package tools, execution sequences, and interpretation modes, allowing different agents to receive distinct capabilities and assigned inferences.Assignments can follow flow-index, concept-name, or sequence-type patterns, or explicit agent identifiers.Source: §6.3 · p. 9

6.4 Agent Sequences: The Execution Pipelines

• Semantic and syntactic inference types use standardized sequences, with imperatives and judgements invoking LLM reasoning and assignment, grouping, timing, and looping handling deterministic data plumbing.Judgements add truth-condition checks, while syntactic sequences remain instant, free, and deterministic.Source: §6.4 · p. 9

6.5 Paradigms: Configuring Agent Behavior

• Paradigms separate construction-time tool preparation from runtime value execution, enabling reusable configuration across inferences and agents.Vertical steps prepare functions during MFP; horizontal steps pass runtime values during TVA.Source: §6.5 · pp. 9–10

6.6 The Canvas App: Visual Debugging

• The Canvas App visualizes inference graphs and live node states, while supporting breakpoints, stepwise execution, tensor inspection, tool monitoring, and checkpoint control.It uses React Flow for visualization, FastAPI for the backend, and WebSocket events for real-time progress.Source: §6.6 · p. 10

6.7 Command-Line Interface

• The CLI supports fresh runs, checkpoint resumes, forks, and listing tracked executions for headless operation.The commands are run, resume, fork, and list-runs.Source: §6.7 · p. 10

7 The Compiler Ecosystem

• The four-phase pipeline transforms natural-language intent into executable JSON repositories through progressive refinement and manual review opportunities.Derivation creates structure, Formalization adds rigor, Post-Formalization supplies execution resources, and Activation generates repositories.Source: §7 · p. 10, §7.1 · p. 11

7.1 The Four-Phase Pipeline

• The Canvas environment makes execution inspectable through graph visualization, node details, tensor inspection, execution state, and real-time progress indicators.The figure distinguishes semantic operations from syntactic operations and reports 18/20 nodes completed.Source: Figure 1 · p. 11

7.2 Derivation: Natural Language to Structure

• Derivation recursively decomposes natural-language instructions into hierarchical concepts, dependencies, and operators for conditionals, loops, and collections.Question types guide the mapping from source text to NormCode structures.Source: §7.1 · p. 10, §7.2 · p. 11

7.3 Formalization: Adding Structural Rigor

• Formalization makes every inference explicit through output-effect relationships, concrete references, and unique hierarchical flow indices.The resulting .ncd has explicit inputs, outputs, and identities, while .ncn translates the structure into prose for domain-expert verification.Source: §7.1 · p. 10, §7.3 · pp. 11–12

7.4 Post-Formalization: Enriching for Execution

• Post-Formalization enriches plans with paradigms, perception norms, tool specifications, resources, axes, tensor shapes, and element types.These annotations connect abstract intent to the normative and reference structures required during execution.Source: §7.1 · pp. 10–11, §7.4 · p. 12

7.5 Activation: Generating Executable Repositories

• Activation generates concept and inference repositories containing typed data definitions, operational flow information, and sequence-specific working_interpretation dictionaries.The repositories provide the configuration expected by the Orchestrator, including inputs, outputs, conditions, grouping, timing, and looping information.Source: §7.1 · p. 11, §7.5 · p. 12

7.6 Translation: Generating Human-Readable Views

• The compiler produces readable .ncn views and hybrid .ncdn editing views so domain experts can verify logic while developers inspect formal-to-natural-language mappings.The pipeline also supports decompilation back to .ncd for debugging, version control, and modification.Source: §7.6 · p. 12, §7.7 · p. 12

7.8 Compilation Guarantees and Limitations

• Compilation guarantees syntactic validity, flow consistency, sequence completeness, reference structure, resource grounding, and working-interpretation completeness.These checks validate the plan’s structure but not whether it achieves its intended goals, runs successfully, is logically sound, or performs optimally.Source: §7.8 · pp. 12–13

8.1 Case Study 1: The Self-Hosted Compiler Pipeline

• The NormCode compiler successfully executed its own approximately 50-inference pipeline and produced concept and inference repositories with intermediate artifacts.Checkpointing supported pause-and-resume execution, while the Canvas App enabled visual inspection of intermediate states.Source: §8.1 · p. 13
• Self-hosting demonstrates expressive completeness, practical viability of the execution toolchain, and recursive validation through re-running the compiler pipeline.The result covers loops, conditionals, and human-in-the-loop steps alongside the orchestrator, checkpointing, paradigm systems, and visual debugger.Source: §8.1 · p. 13

8.2 Case Study 2: Base-X Addition Algorithm

• 100% accuracy was achieved on base-X addition across varying digit lengths, with validation up to 150-digit numbers.The task handled arbitrary bases, carry-over, and nested loop structure; final outputs were deterministic through Python-executing paradigms.Source: §8.2 · p. 13

8.3 Implementation Evidence: The Canvas App

• The Canvas App demonstrates real-time graph visualization, WebSocket execution streaming, breakpoint debugging, tensor inspection, multi-agent configuration, and checkpoint resume or fork capabilities.These features provide practical evidence that execution state and workflow structure can be inspected interactively.Source: §8.3 · pp. 13–14

8.4 Qualitative Observations

• Formal statistical experiments and comparative evaluation against direct prompting, LangChain, and other frameworks are planned for future work.The current evidence therefore consists of demonstrations, implementation evidence, and qualitative observations.Source: §8.4 · p. 14
• Flow indices and the Canvas App localize failures by identifying the failed step, its inputs, and its graph connections.The qualitative observations describe failed nodes appearing in red with highlighted input connections.Source: §8.4 · p. 14
• Perceptual signs reduce token costs by passing lightweight pointers, while syntactic operations incur no LLM cost regardless of manipulated data volume.Actual content is materialized only when an inference needs to operate on the data.Source: §8.4 · p. 14
• SQLite-backed checkpointing supports pausing and resuming long-running compilations without losing state.The same checkpoint mechanism supports inspecting intermediate states before continuation.Source: §8.4 · p. 14

9.1 When to Use NormCode

• NormCode targets high-stakes decisions, complex workflows, long-running executions, and human-AI collaboration where traceability, debugging, checkpointing, or review are important.The multi-format ecosystem lets technical teams work in .ncd while domain experts review .ncn narratives.Source: §9.1 · p. 14
• The framework is a poor fit for simple Q&A, rapid prototyping, and real-time applications where formalization overhead or orchestration latency is unacceptable.Its intended sweet spot is where reliability and transparency outweigh the cost of explicit structure.Source: §9.1 · p. 14

9.2 Limitations and Tradeoffs

• The .ncd notation creates visual clutter and requires familiarity with dense syntax, although .ncds, .ncn, and graphical Canvas views improve usability.IDE plugins with syntax highlighting and folding are identified as further improvements.Source: §9.2 · p. 14
• NormCode expands simple operations into longer plans, making verbosity an explicit cost of explicit data flow.The paper states that marginal verbosity decreases for complex workflows while debugging benefits compound with complexity.Source: §9.2 · p. 15
• Manual .ncd editing is brittle because indentation and flow indices are tightly coupled, so the compiler should remain the primary modification path.The .ncdn editor and Canvas App partially mitigate this by validating changes in real time.Source: §9.2 · p. 15
• NormCode depends on an integrated orchestrator, compiler, reference system, and ideally Canvas App, limiting portability compared with simpler code frameworks.The paper presents this toolchain dependency as necessary for isolation, checkpointing, and auditability guarantees.Source: §9.2 · p. 15

9.3 Broader Implications

• The multi-format ecosystem provides multiple stakeholder-optimized views of shared logic, while semantic/syntactic separation enables cost attribution and reliability mapping.The Canvas App further shows that visualization and execution logic can be decoupled while supporting graph inspection and breakpoint debugging.Source: §9.3 · p. 15
• Checkpoint and fork capabilities frame AI workflow development as an iterative process of inspecting state, testing alternatives, and retaining successful branches.This resembles software development with version control more than traditional scripting.Source: §9.3 · p. 15

10 Future Work

• Compiler robustness remains a priority because natural-language-to-.ncd derivation is sensitive to instruction complexity and prompt design.Proposed directions include fine-tuned models, iterative validation and correction, and human sketches completed by LLMs.Source: §10 · p. 15
• Real multi-agent coordination remains unexplored despite support for multiple Subjects with different tool bodies and inference-agent mappings.Future directions include negotiation, delegation, and conflict-resolution protocols.Source: §10 · p. 15
• Domain-specific extensions could add semantic types, validation rules, and compliance reports for legal, medical, and financial workflows.Examples include evidence requirements for diagnoses and risk disclosures for financial recommendations.Source: §10 · p. 16
• Rigorous comparative studies, expert user studies, and longitudinal production evaluations are needed to quantify cost-accuracy tradeoffs and practical value.Suggested comparisons include direct prompting, LangChain, and AutoGPT on established datasets.Source: §10 · p. 16
• Performance optimization could reduce semantic-operation costs and latency through batching, caching, memoization, and parallel execution of independent operations.These optimizations target repeated patterns and dependency-permitted parallelism.Source: §10 · p. 16
• Production integration requires enterprise LLM endpoints, authentication and rate limiting, observability systems, and containerized or serverless deployment support.These integrations are identified as requirements for deployment with existing infrastructure.Source: §10 · p. 16

• Each inference accesses only explicitly passed inputs, preventing later steps from accessing earlier raw data unless it is passed forward.The compiler and orchestrator enforce this isolation as a language-level constraint rather than a convention.Source: §11 · p. 16
• Separating semantic LLM reasoning from syntactic deterministic data flow lets auditors distinguish probabilistic inference from mechanical restructuring.This separation contributes to process auditability within the workflow.Source: §11 · p. 16
• NormCode’s multi-format ecosystem provides natural-language, formal, verification, and hybrid views of the same underlying logic for different stakeholders.These views support domain-expert verification, developer debugging, precise auditing, and formal execution.Source: §11 · p. 16
• A four-phase compilation pipeline progressively formalizes plans while preserving semantic intent and allowing manual review at critical stages.The phases are Derivation, Formalization, Post-Formalization, and Activation.Source: §11 · p. 16
• The Canvas App adds real-time graph visualization, breakpoint debugging, tensor inspection, and multi-agent configuration for observable execution control.These capabilities make the audit trail visually explorable rather than merely stored.Source: §11 · p. 16
• 100% accuracy on base-X addition and self-hosted execution of NormCode’s compiler validate algorithmic correctness and structured execution.The demonstrations are presented as evidence that structured intermediate representations can connect human planning with machine execution.Source: §11 · p. 16
• NormCode is not suited to every setting because simple tasks may not justify its overhead and real-time applications may not tolerate orchestration latency.The paper positions it mainly for high-stakes domains where tracing each step’s inputs matters.Source: §11 · p. 16

A.1 Input Specification

• The input specification stores number pairs as JSON data with tensor axes, while %() wraps raw values as perceptual signs for later interpretation.The example input contains the pair 123 and 98.Source: §A.1 · p. 18

A.2.1 Natural Language Translation (.ncn Format)

• The natural-language representation labels outputs, actions, inputs, yields, timing, conditions, and flow indices to make execution readable and debuggable.Bracketed indices serve as unique flow addresses, while conditions control whether actions execute.Source: §A.2.1 · p. 18
• Each iteration constructs shifted number pairs by removing the last digit, while carrying forward the current carry-over state across number pairs.The shifted number is zero when the current number is less than 10; otherwise its unit-place digit is removed.Source: §A.2.1 · pp. 18–19
• The addition loop extracts unit-place digits, sums them with the current carry, produces a remainder digit, and computes a quotient for the next carry.The digit sum uses all unit-place values together with the carry-over number; division by 10 yields the quotient and remainder.Source: §A.2.1 · pp. 18–19
• The loop appends a new number pair only when not all numbers are zero and the carry-over number is zero.The termination predicates are evaluated after the candidate pair is prepared.Source: §A.2.1 · p. 19

A.2.2 Formal Syntax (.ncd Format)

• The formal .ncd syntax encodes quantification, grouping, imperative operations, timing, assignments, and zero-value judgements with structured markers.Its entries represent operations such as collecting unit-place values, summing them with carry, and computing quotient and remainder outputs.Source: §A.2.2 · pp. 19–21

A.3 Concept Repository

• The concept repository contains over 50 concepts spanning input pairs, carry state, digit extraction, loops, grouping, summation, and zero checks.Ground concepts hold reference data, while functional concepts define the operations used by the plan.Source: §A.3 · p. 21

A.4 Inference Repository

• The inference repository contains 23 entries describing working interpretations for the outer loop, digit summation, and conditional termination.These entries specify sequence types, concepts, inputs, context, value ordering, and conditions.Source: §A.4 · p. 21