JSE: A Structural Expression Protocol for AI Systems

Abstract

Modern AI systems can reliably generate structured JSON outputs but lack a native mechanism to express composable structural logic within that format. JSON is a data representation language; it is not a structural computation language.

JSE (JSON Structural Expression) introduces a structural layer over JSON that enables deterministic interpretation of symbolic expressions while preserving full JSON validity.

In analogy to abstract algebra, where a group is defined as a set equipped with an operation, JSE may be understood as:

JSON equipped with S-expression structure.

JSE transforms JSON from a passive data container into a medium capable of expressing structured intent.

1. Introduction

The rapid evolution of AI systems has led to a widespread reliance on structured output formats such as JSON. Large language models can reliably:

  • Produce syntactically valid JSON
  • Conform to JSON Schema
  • Generate nested structured data

However, JSON remains fundamentally declarative. It expresses data, not structured logic.

Current approaches to bridge this gap include:

  • Tool calling mechanisms
  • Message control protocols
  • DSL embedded in strings
  • Custom RPC formats

These approaches suffer from limited composability, poor nesting semantics, or ambiguity.

JSE proposes a structural solution:

Instead of embedding logic outside JSON, extend JSON structurally while remaining valid JSON.

2. The Structural Gap in AI Systems

JSON has the following properties:

  • Tree-structured
  • Deterministic
  • Schema-constrainable
  • Widely supported

But it lacks:

  • Symbolic operators
  • Structural evaluation semantics
  • Controlled composability
  • Quotation mechanisms

AI systems therefore rely on external protocols (e.g., function calls) that introduce:

  • Implicit execution layers
  • Non-composable calls
  • Flat invocation models

The absence of structural expression inside JSON creates a structural gap between data and intent.

3. JSE as a Structural Layer

JSE introduces one minimal structural rule:

Strings beginning with $ are interpreted as symbols in structural position.

With two expression forms:

  1. Positional (Array Form)
  2. Named (Object Form)

Example:

["$add", 1, 2]

or

{
  "$add": [1, 2],
  "source": "user"
}

Both remain valid JSON.

This creates a structural expression tree without introducing a new syntax.

4. Deterministic Structural Interpretation

JSE does not define execution semantics.

It defines:

  • Structural recognition rules
  • Symbol identification
  • Quotation control
  • Deterministic parse behavior

This ensures:

  • Machine interpretability
  • Stable structural decoding
  • No ambiguity
  • No hidden runtime assumptions

5. Composability Beyond Tool Calls

Tool call protocols typically look like:

{
  "name": "add",
  "arguments": { "a": 1, "b": 2 }
}

These are:

  • Flat
  • Not recursively composable
  • Procedural in style

JSE allows nested structural composition:

["$add", 1, ["$multiply", 2, 3]]

This supports:

  • Nested computation trees
  • DSL construction
  • Controlled interpretation depth
  • Declarative symbolic reasoning

JSE therefore provides:

Composability as a first-class structural property.

6. Controlled Expressiveness

JSE intentionally does not aim for:

  • Turing completeness
  • General-purpose programming
  • Macro systems
  • Implicit execution

Instead, it provides:

  • Structural abstraction
  • Symbolic representation
  • Declarative composition

Execution remains optional and implementation-defined.

This makes JSE suitable for:

  • Policy definition
  • Agent planning trees
  • Structured decision graphs
  • Safe symbolic communication
  • Constrained DSL environments

7. JSE as an AI Structural Protocol

JSE can function as a protocol layer between:

  • AI models
  • Orchestration systems
  • Deterministic interpreters
  • Execution sandboxes

Because:

  • It is valid JSON
  • It is schema-checkable
  • It is deterministic
  • It is structurally composable

It avoids:

  • Implicit execution
  • Text parsing ambiguity
  • Prompt-based DSL hacks

This positions JSE as:

A structural protocol for symbolic AI communication.

8. JSON + Structure: A Conceptual Model

Let:

  • J be the set of valid JSON values
  • P be the structural interpretation function

Then:

JSE = (J, P)

Where P introduces symbolic structural recognition without altering JSON validity.

This mirrors algebraic structure:

  • JSON provides the set
  • JSE provides structure

9. Security Implications

Because JSE does not mandate execution:

  • It is not inherently dangerous
  • Execution must be explicitly defined
  • Interpretation can be sandboxed
  • Operators can be whitelisted

This makes JSE safer than implicit code generation approaches.

10. Future Directions

Potential extensions include:

  • Canonical structural normalization
  • Minimal core operator set
  • JSON Schema integration patterns
  • Static structural validation
  • AI alignment DSL frameworks

11. Conclusion

JSE demonstrates that minimal structural augmentation of JSON can produce a powerful compositional protocol suitable for AI systems.

Rather than replacing JSON or reinventing Lisp, JSE introduces:

  • Symbol recognition
  • Structural determinism
  • Controlled composability

In doing so, it enables JSON to carry structured intent.