Governance proposal · Draft 0.1 for public comment

Neuron Design Standard

A proposal for organizing AI governance around how neurons are designed. It describes three different paths one can take to build a neuron network. They set out the foundational methods and conditions a design must meet to be established as artificial intelligence, and why one path may suit a goal better than another. Each path is held to the same task, and each design discloses what a reviewer needs to assess security, ethics, reliability and prediction in one place.

Status. This is a draft reference prepared as a template that an agency or standards body could review and adopt. It is not an official publication of the United States Government or any agency, and it carries no government endorsement.

Three paths to a neuron network

These are the foundational methods and conditions proposed for establishing an artificial intelligence: a design starts from one of these three paths and must meet the shared conditions below. They are different paths, not ranks. Each answers the same question: how does one unit turn what it receives into one state? The paths differ in how they weight, combine and check what comes in, and in whether a neuron only relays information or also builds the network. Path 3 may differ most in structure, but it has to achieve the same task, sequence pattern analysis, and keep the order of Paths 1 and 2.

Neuron designhow one unit turns input into one state
Path 1 · Cascade

Weighted layers

Inputs are scaled by learned weights, summed with a bias and passed through an activation function. Units are stacked in layers that cascade forward. Weights are set by gradient descent and backpropagation.

Established, peer reviewed
  • Width and depth. More units per layer, more layers.
  • Data. More training examples.
  • Compute. Loss follows measured power laws in parameters, data and compute.
Path 2 · Reflexive build

LEATR reflex shells

Each data point carries one integer angle state, 45.0° at most. It is checked against 7 natural tools, 3 shells and 3 FRP stages, and context from emotion, grammar and reflex position moves the one angle.

Proposed by its developer
  • Fixed 63 checks. 7 tools × 3 shells × 3 stages for every data point.
  • Angle precision. One to six decimal places, added only to tell states apart.
  • Integer arithmetic. Cost grows linearly with data points.
Path 3 · Open design

Declared structure

Any other method that achieves the same task, sequence pattern analysis. It can use any structure, but it must weigh before it combines, bring context before its checks, and publish how it scales.

Conformance based
  • Declared axes. The design names what it scales and in what unit.
  • Declared cost. Cost per stage is stated for each axis.
  • Declared evidence. Performance claims come with their source.

The order each path follows

Every path does the same job: sequence pattern analysis. Each one gets there in its own order. Cascading belongs to weighting, because every layer compares what it receives against its weights and hands the result on. Reflexive shells follow their own order of angle, context, checks and shells. Any other method is welcome if it achieves the same task and keeps the order of these two.

Path 1 · CascadeWeighting, then cascadeSpecific to weighted layers.
  1. 1InputsThe sequence arrives as x₁ to xₙ.
  2. 2WeightEach input is compared against its weight.
  3. 3SumProducts add up with a bias.
  4. 4ActivateAn activation function sets the output.
  5. 5CascadeThe result feeds the next layer, which weights it again.
Pattern resultThe last layer's output over the whole sequence.
Path 2 · Reflexive buildAngle, context, checks, shellsSpecific to reflexive shells.
  1. 1AngleEach data point gets one integer angle state.
  2. 2ContextEmotion, grammar, math order and reflex position refine the angle.
  3. 363 checks7 tools × 3 shells × 3 stages collapse to one angle.
  4. 4ShellsFoundation, Reflex, Performance across outer, middle, inner.
  5. 5FieldThe sequence leaves as one field state.
Pattern resultA field over N variable states, such as mfdb0.0 for 1+1=, and what it completes to.
Path 3 · Open designAny method with the same resultMust keep the order of both paths.
  1. 1IntakeStates what a data point is and keeps sequence order.
  2. 2CompareStates what each point is weighed or compared against, before anything combines.
  3. 3CombineStates how compared values merge.
  4. 4CheckStates its threshold, activation or reflex check. Context comes before it.
  5. 5ResultStates the one result for the sequence.
Pattern resultDeclared, and published with how it scales.
Sequence pattern analysis, the task all three achieve Keep the data points in order. Give each one a state. Return one result for the whole sequence. A design that cannot do all three does not qualify as any path.

One neuron, three breakdowns

The same neuron body is shown under each path. Drag sideways to turn it. The five rings along the neuron are that path's five steps, in order. Pick a path to see what happens at each one.

Example values only. Weights are illustrative.
Path 1 · Cascade

Weighted sum and activation

    Conformance

    A design may call itself Path 3 when it achieves sequence pattern analysis and meets every MUST below. Path 1 and Path 2 names are reserved for designs that implement those paths as described here.

    Rules

    • MUSTAchieve sequence pattern analysis: keep data points in order, give each a state, return one result for the sequence.
    • MUSTDeclare what happens at each of the five steps, weigh or compare before combining, and bring context before its checks.
    • MUSTPublish each scaling axis, its unit, and the cost per stage as that axis grows.
    • MUSTState an evidence level: Established (peer reviewed and replicated), Proposed (published by the designer, not independently validated) or Declared (conformance only).
    • MUST NOTUse the name Path 1 or Path 2 unless the design implements that path as described.
    • SHOULDPublish a Neuron Disclosure Record with these answers in one place.
    • SHOULDState numeric precision and whether results are reproducible.

    Check a design

    Example state for a hypothetical design. Tick each item the design meets.

    What this gives AI governance

    Meeting the foundational conditions is the starting point for governance, not proof that a design is secure, ethical, reliable or predictable. The standard requires each design to put the facts a reviewer needs in one record, in the same shape for every path, so claims can be checked and compared.

    Security

    • What a data point is, what enters the unit and what leaves it.
    • What leaves the device or the system, and whether the user chose to share it.
    • Whether any step runs outside code or evaluates user text as code.

    Path 2 is built on integer arithmetic with no outside evaluation. Path 1 and Path 3 designs state their own boundaries.

    Ethics

    • Which context shapes the result: emotion, grammar, history, location, anything else.
    • What is stored or learned from a person's input, and what is not.
    • Where a person can see, limit or switch off that context.

    Path 2 names its emotional context openly, since emotion moves the angle. Path 1 states its training data sources.

    Reliability

    • Sequence pattern analysis results on a published set of test sequences.
    • Numeric precision and the known limits of the design.
    • What happens when an input falls outside what the design handles.

    Every path is measured on the same task, so results can be set side by side.

    Prediction

    • Whether the same sequence always gives the same result, and if not, why.
    • How the result changes as the design scales along each declared axis.
    • How far past tested conditions the stated results are expected to hold.

    Path 1 reports random seeds and measured scaling laws. Path 2 states that its fixed 63 checks make results repeatable for a given input and context.

    What this proposal asks of a reviewing body

    1. Review the three paths, the sequence task and the evidence levels, and publish comments.
    2. Adopt the Neuron Disclosure Record as a common format for describing a design.
    3. Run a pilot in which designs from each path are tested on the same published sequences and reported side by side.

    Why one path may suit a goal better

    The paths are different ways to build a network of neurons. A neuron can relay information, passing a value on, and it can also build, adding to the network itself. How much each path does of either is what makes one more suitable than another for a given goal.

    Path 1 · CascadePath 2 · Reflexive buildPath 3 · Open design
    What the neuron doesRelays: weighs its inputs and passes one value forwardRelays and builds: besides passing its state on, it builds the network onwardWhatever the designer declares: relay, build, or both
    Where the structure comes fromSet by the designer before training. Learning changes the weightsGrown from the neurons themselves, in the order of angle, context, checks and shellsDeclared by the designer, and it must keep the order of Paths 1 and 2
    Suits best whenPatterns are learned from large amounts of data, with mature tools and benchmarksThe network must grow itself and every step must be traceable and repeatableA new method needs room, while staying comparable on the same task
    LimitsNeeds large data and compute. The reasons for an output are hard to traceNot yet independently validated. Few outside tools or published benchmarksClaims rest on the designer's disclosure until tested
    The developer's assessment The developer of Path 2 considers it the most optimal and most advanced of the three paths, because its neurons build as well as relay. This is the developer's assessment. It has not been independently tested. The pilot in this proposal, with every path run on the same published sequences, is how the claim would be checked.

    How each path scales

    Scaling means growing a design while keeping its steps and its sequence result intact. The table states the axes, the cost behavior and the status of the evidence for each path.

    Path 1 · CascadePath 2 · Reflexive buildPath 3 · Open design
    Unit of weightingLearned weight per connection, plus a bias per unitOne angle per data point, 45.0° at most, refined by context anglesDeclared by the design
    GateActivation function such as ReLU or sigmoidFoundation, Reflex, Performance checked in order across outer, middle and inner shellsDeclared by the design
    Scaling axesParameters (width and depth), training data, computeAngle precision (1 to 6 decimals); sequence length. Tools, shells and stages are fixed at 7, 3 and 3Each axis the design names, with a unit
    Cost behaviorGrows with parameters and with training tokens63 checks per data point, integers only, so cost grows linearly with data pointsStated per stage for each axis
    Evidence statusEstablished. Scaling laws measured in 2020 and 2022Proposed by its developer. Independent validation not yet publishedDeclared by the designer

    Sources for Path 1

    1. McCulloch, W. S. and Pitts, W. (1943). A logical calculus of the ideas immanent in nervous activity. Bulletin of Mathematical Biophysics 5.
    2. Rosenblatt, F. (1958). The perceptron: a probabilistic model for information storage and organization in the brain. Psychological Review 65.
    3. Rumelhart, D. E., Hinton, G. E. and Williams, R. J. (1986). Learning representations by back-propagating errors. Nature 323.
    4. Kaplan, J. et al. (2020). Scaling laws for neural language models. arXiv:2001.08361.
    5. Hoffmann, J. et al. (2022). Training compute-optimal large language models. arXiv:2203.15556.

    Path 2 describes the LEATR (Lead Edge Ash Tree Reflex) and BRPN (Buoyancy Reflex Pendulum Node) framework by DART Meadow and Radical Deepscale LLC. It is included as a proposed design and has no independent source list yet. A companion risk-management guide, such as the NIST AI Risk Management Framework 1.0, can sit alongside this standard for governance of how a design is used.