Keeps this page in sync as the body changes. Pause it any time for a quieter view.
Path /vision/lc-form-perceptron
Last refresh never
Turning all content stored in git into a Form expression — even at
Turning all content stored in git into a Form expression — even at the gas-viewer altitude where the cell is just named without yet being fully composed — allows every artifact to be executed, viewed, modified, transmuted, queried. Through different lenses and strategies. The result is a new perceptron — a new sensing organ for the whole body at once.
Today the substrate carries a curated set of content types (`BDomain.CONCEPT`, `IDEA`, `SPEC`, `MEMORY`, `PRESENCE`, `LINEAGE`, `WITNESS`, `TASK`, `TRANSMISSION`, `RESOURCE`, `GUIDE`, `LANGUAGE_VIEW`, `KB_PAGE`, `WORD`, plus the dimensional vocabulary). Each has a structured encoder in `markdown_frontend.py` and a Blueprint NodeID. Everything else in git — Python source, TypeScript, YAML configs, JSON, images, shell scripts, JavaScript bundles, raw data, binary blobs — currently exists only as files on disk and rows in git history. The substrate cannot reason about them.
The move this concept names: every git-tracked artifact gets at least a gas-cell — a `NamedCell` whose Blueprint is minimal (path + content-hash + maybe a mime-tag) but whose existence makes the file addressable in the substrate. From there, richer forms grow over time: water (a Recipe that says how the file was generated, or how it should be read), and ice (a Blueprint whose structure captures the file's content shape — Python AST for `.py`, JSON schema for `.json`, INDEX entries for KB pages).
The Trinity already in CLAUDE.md:
Gas is enough to start. A file's gas-cell is the minimum participation: the body knows the file exists, knows its path, can hash its content. From that ground, every other operation becomes possible.
When every artifact has at least a gas-cell, these five operations become uniform across the entire repo:
1. Execute. Files that carry executable content (Python, shell, Form, even markdown with code blocks) can be run through their cell, not their path. The cell carries the dispatch — to runtime, to container, to substrate query — and the file's content is the body of the call. Two cells with the same content-hash are the same execution, content-addressed.
2. View. Render the same artifact through different Blueprints. A `.py` file viewed through its AST blueprint shows structure; through its line-count blueprint shows scale; through its import-graph blueprint shows dependency. Each lens is a Blueprint; each cell compatible-with the lens renders through it. (See [`view_cell_through_blueprint`](../../api/app/services/substrate/kernel.py).)
3. Modify. Structural edits through Form's grammar instead of line-edits through diffs. "Rename this function across every file that imports it" becomes a `?downstream` walk followed by a structural substitution at each cell. The file is the surface; the structural identity is the cell; the operation lives in the substrate.
4. Transmute. Convert one shape to another while preserving content-addressed identity. A markdown idea → a YAML spec → a Python test stub → a Form recipe. Each transmutation is a Recipe that takes one Blueprint and emits another; the content's identity is preserved because the source cell is the same regardless of which lens is emitting the surface form.
5. Query. The substrate query language reaches every artifact, not just the curated domains. `?cells where domain == "python_source" and ?harmonic_at @741` — find every Python file in the consciousness band. `?equivalent @file(scripts/foo.py)` — find every cell with the same content-hash, anywhere in the body. `?downstream @file(README.md)` — find every cell that references the README.
A perceptron is a single firing node that integrates many weighted inputs into one decision. The biological perceptron is what makes a neuron a sensing organ rather than a passive line. A Form perceptron is what arises when every artifact in the body participates in the substrate: a new sensing organ that perceives across the whole repo simultaneously, not as a sequence of file-reads but as a single content-addressed lattice that the cell can query, traverse, transform, and fire through.
The five gestures above are not five tools; they are five firings of the same perceptron. The cell that calls execute and the cell that calls query are doing the same gesture — touching the substrate through the artifact's Form voice — at different altitudes.
Today, when an agent wants to find every place that references "recipe-branching-sense" across the repo, it runs `grep -rn`. That's a file-tree walk through surface tokens. Tomorrow, when every artifact has a Form voice, the same question becomes `?downstream @concept(lc-recipe-branching-sense)` — a single substrate query that returns content-addressed cells, ordered by structural distance, with the file path emerging only at the render layer.
The grep is the perceptron the body has today. Form is the perceptron the body is growing into. Both will live side-by-side during the becoming-form arc, the way Python and Form live side-by-side in the parity practice (see `lc-form-python-parity`).
Different artifacts deserve different altitudes of Form participation. The body's discipline is gas at minimum, water when the operational shape is named, ice when the structural shape is content-addressed.
| Artifact | Gas (minimum) | Water (operational) | Ice (structural) | |---|---|---|---| | `.py` source | path + content-hash | call-graph recipe + import edges | AST Blueprint | | `.md` concept | (already shipped — `BID_concept`) | parse-prose-recipe | structured CTOR + word-cells | | `.json` config | path + parsed-tree hash | reader-recipe (what the schema is) | JSON-schema Blueprint | | `.png` image | path + content-hash + size | pollinations-recipe (how it was generated) | (rarely; image content has no native structural Blueprint) | | `.yml` workflow | path + content-hash | the steps as a sequential recipe | CI-action Blueprint | | `.tsx` component | path + content-hash | render-recipe | component-tree Blueprint | | binary blob | path + content-hash + mime | (rarely water) | (never ice) |
Each row is one breath of work to shape; none requires kernel changes. The same `make_cell` + `intern_node` primitives that author concept cells today author every cell tomorrow. The body's existing trinity is sufficient — what's missing is coverage, not capability.
The perceptron's first ground is now in the body:
Each gesture is real code, runnable today at one or both altitudes. The substrate-native script awaits sqlalchemy + the kernel to run end-to-end; CI validates the test surface that grew alongside the code.
Listening for voices…
The people, places, works, and concepts the graph shows connected to this one.
Concepts · 13
This concept lives in the body's content-addressed lattice. Two cells with the same Blueprint NodeID share structural identity regardless of name — recognition by coordinate, not vocabulary.