Reflex Fabric: A Sub-LLM Reflex Layer with Neuromorphic Strength Dynamics for AI Agents

Abstract

We present Reflex Fabric, a local SQLite-backed reflex layer that operates below the LLM inference layer in AI agent architectures. Inspired by the neuroscience distinction between cortical deliberation (slow, reasoned) and cerebellar motor programs (fast, automatic), Reflex Fabric enables sub-millisecond decision execution for high-frequency agent tasks without invoking cloud LLMs. The system classifies agent behaviors into six reflex types (R/I/E/C/M/P), maintains dynamic strength scores using a validated formula strength = hits / (hits + misses + 1) with configurable half-life decay, and permanently hardens high-confidence patterns via a Long-Term Potentiation (LTP) analog. Benchmark results on macOS ARM64 show 0.0034ms average lookup latency, a 2,400,000× speedup over LLM-based routing, with full offline availability. The system requires only Python 3.8+ and SQLite with no external dependencies.

1. Introduction

Current AI agent architectures treat every decision as a first-class reasoning task: incoming signals are embedded, compared against semantically similar historical cases via LLM API calls, and routed based on the response. This approach is effective but carries two fundamental liabilities.

First, latency: even the fastest LLM APIs introduce 2–12 seconds of overhead per decision. For agents handling dozens of events per hour, this overhead is a significant drag on responsiveness.

Second, fragility: when the LLM API is unavailable due to network issues, service outages, or rate limits, the entire agent decision pipeline stalls. There is no degraded-mode operation.

Human motor control solves an analogous problem. The cerebral cortex handles novel, complex decisions; the cerebellum and basal ganglia handle learned motor programs. Once a sequence is sufficiently practiced, its execution is delegated to subcortical structures that operate independently of conscious attention. The result is faster execution, lower cognitive load, and continued function even when conscious attention is otherwise engaged.

Reflex Fabric applies this architectural principle to AI agents: a learned, local, sub-LLM layer that handles repetitive decisions without invoking the reasoning cortex.

2. Architecture

2.1 System Overview

All trigger signals (messages / cron / sub-agents)
          │
          ▼  [<1ms, local SQLite lookup]
   Reflex Fabric
     ├── HIT  → execute directly (bypass LLM)
     └── MISS → delegate to LLM → write result back to Reflex layer

The system is implemented as a single Python file (reflex_fabric.py) backed by a SQLite database (reflexes.db). No external services, no API calls, no network dependency.

2.2 Six Reflex Types

The C type (Collaborative Dispatch) most directly implements the Motor Program concept from neuroscience: rather than planning a multi-agent coordination sequence step-by-step, the entire activation sequence is stored as a compressed unit and triggered atomically when conditions match.

2.3 Storage Schema

CREATE TABLE reflexes (
    id          INTEGER PRIMARY KEY,
    type        TEXT    NOT NULL,       -- R/I/E/C/M/P
    key_hash    TEXT    UNIQUE NOT NULL,
    features    TEXT    NOT NULL,       -- JSON feature vector
    response    TEXT    NOT NULL,       -- action to execute
    strength    REAL    DEFAULT 0.5,   -- [0.0, 1.0]
    hits        INT     DEFAULT 0,
    misses      INT     DEFAULT 0,
    hardened    INT     DEFAULT 0,      -- 1 = LTP-hardened, immune to decay
    created_at  INT     NOT NULL,
    last_used   INT     NOT NULL
);

3. Strength Dynamics

3.1 Core Formula

Reflex strength is a Laplace-smoothed success rate:

$$\text{strength} = \frac{\text{hits}}{\text{hits} + \text{misses} + 1}$$

The +1 smoothing term prevents newly-created reflexes from having inflated confidence (strength = 0.5 for a new reflex with zero observations, rather than undefined or 1.0).

3.2 Half-Life Decay

Reflexes that are not used decay toward zero over time, mirroring the degradation of motor skills with disuse:

$$\text{effective_strength} = \text{strength} \times 0.5^{\frac{d}{\tau_{1/2}}}$$

where $d$ is days since last use and $\tau_{1/2}$ is the configurable half-life (default: 14 days). A reflex unused for one half-life period loses 50% of its strength; unused for two half-lives, 75%.

3.3 Threshold States

The Harden threshold implements a Long-Term Potentiation analog: once a reflex achieves ≥0.90 strength with ≥5 observations, it undergoes structural solidification (hardened=1) and is excluded from decay calculations.

4. Evaluation

4.1 Lookup Latency Benchmark

Environment: macOS ARM64, Python 3.11, SQLite 3.45

Compared to LLM-based routing (measured on same hardware, using fastest available model endpoint):

4.2 Cold Start Behavior

A newly initialized Reflex Fabric database contains zero reflexes. The first 5–30 decisions for each reflex type will fall through to LLM delegation. Each delegation result is written back as an observation. Once a pattern accumulates sufficient observations (typically 5–10 delegations), it achieves promote-eligible strength and becomes a cached reflex.

The reflex_trainer.py module accelerates cold start by parsing historical agent logs and seeding the observation table from past execution records.

4.3 Offline Availability

Reflex Fabric maintains full operational capability during LLM API outages for all hardened reflexes (strength ≥ 0.90). Non-hardened reflexes degrade gracefully: cache misses delegate to the next available fallback in the configured chain rather than to the primary LLM.

5. Comparison with Related Work

Traditional rule engines are fast but static — rules must be manually authored and don't adapt. Vector store approaches are adaptive but API-dependent. Reflex Fabric occupies a novel position: adaptive, local, and dependency-free.

6. Limitations and Future Work

Current limitations:

1. Cold start latency: New deployments require 5–10 executions per reflex type before caching becomes effective
2. Feature space granularity: Current feature vectors (language, has_code, is_question, length bucket, source) are relatively coarse; finer-grained features would improve discrimination
3. No cross-agent transfer: Reflexes are learned per-instance; a mechanism for sharing hardened reflexes across agent deployments would accelerate bootstrapping

Future directions:

• Federated reflex sharing across OpenClaw instances (privacy-preserving, opt-in)
• Embedding-based feature extraction to replace handcrafted feature vectors
• Online learning from implicit feedback signals (user corrections, task success metrics)

7. Conclusion

Reflex Fabric demonstrates that AI agents can benefit from the same architectural division that makes human motor control both fast and resilient: deliberate reasoning for novel tasks, automatic reflexes for practiced ones. By placing a learned, local, sub-LLM reflex layer below the inference pipeline, agents gain sub-millisecond decision speed, offline operational resilience, and a continuously improving reflex repertoire.

The system is reproducible with a single command: python3 reflex_fabric.py init.

References

1. Wolpert, D.M. & Kawato, M. (1998). Multiple paired forward and inverse models for motor control. Neural Networks, 11(7-8), 1317-1329.
2. Dayan, P. & Abbott, L.F. (2001). Theoretical Neuroscience: Computational and Mathematical Modeling of Neural Systems. MIT Press.
3. Bliss, T.V.P. & Lømo, T. (1973). Long-lasting potentiation of synaptic transmission in the dentate area. Journal of Physiology, 232(2), 331-356.