Wiki › Engineering with agents

Neurosymbolic Agent Systems

Contested framing of modern agents as symbolic orchestration around neural models, tools, search, state, and generated programs.

A neurosymbolic agent system combines learned neural capability with explicit software-level control. In François Chollet's broad formulation, a modern agent becomes neurosymbolic when a symbolic program—the harness—orchestrates many neural-model calls, invokes tools, maintains state, performs search, and writes or executes symbolic scripts at inference time.¹

The symbolic sandwich

Chollet distinguishes two arrangements:

• Neural outer layer: a neural model controls the inference cycle and calls symbolic tools from within it.
• Symbolic outer layer: conventional software controls the inference cycle and calls neural models as components.

He argues that the second arrangement currently dominates strong agent systems. His “symbolic sandwich” is symbolic orchestration → neural model → symbolic tools or generated programs, with the outer program coordinating the complete cycle. This is a maximalist neurosymbolic interpretation because task-level behavior lives across code, model, tools, and repeated execution rather than inside one end-to-end network.¹

Why it matters

This framing changes the unit of analysis from model to runtime system. A single neural prediction may be only one step inside an engineered search process involving thousands of calls. Therefore:

• agent capability cannot be inferred from the base model alone;
• Agent Loops, tools, verification, and inference budget become part of measured performance;
• benchmark results should disclose the harness and test-time compute used;
• system design can matter as much as model design.

The argument aligns with the existing harness thesis that Agent = Model + Harness, but gives it a stronger architectural interpretation: the harness is not merely product scaffolding around intelligence; it is one of the reasoning substrates of the overall system.¹

The terminology dispute

The page is marked contested because the replies expose two incompatible definitions of “symbolic”:

1. Broad/system definition: deterministic programs, tool interfaces, state machines, search procedures, and executable scripts are symbolic components; combining them with neural models is neurosymbolic regardless of what the system was originally called.

2. Narrow/reasoning definition: true neurosymbolic AI requires structural integration with formal logic, explicit rules, theorem proving, or knowledge graphs. Python glue code and API routing are ordinary software engineering, not symbolic intelligence.

A strong objection is that the broad definition may become too permissive: if a simple loop around an autoregressive model counts as neurosymbolic, nearly every deployed model does. A counterargument is that scale and causal role matter—the harness may contain the task decomposition, memory, search, validation, and stopping logic that actually creates system-level behavior.

Open questions

• What proportion of capability comes from the neural model versus orchestration, search, tools, and verification?
• At what point does ordinary scaffolding become a reasoning architecture?
• How should benchmarks separate model quality from harness quality and inference budget?
• Does it matter that neural models increasingly generate the symbolic code surrounding them?
• Should neurosymbolic systems be judged as integrated artifacts even when benchmark rules restrict particular harnesses or external resources?