42-software-driven-ssd

Valuation

Generous asset valuation: $20,000,000,000. The listed price is the platform maximum; acquisition at valuation is handled by direct enquiry.

Software-Driven SSD — Cri-One Storage Hardware Family

Software-Driven SSD — Cri-One Storage Hardware Family

Master index of all projects: PROJECTS_INDEX.

Last edited: 2026-05-02

Status: Three custom storage / accelerator hardware designs in active development

Maturity (per PACKAGE_ARCHITECTURE.md): L2 (Designed) — KiCad schematics, BOMs, mechanical / power / architecture documentation on file

Inventor: Christopher Gabriel Brown

Contact: crioneaka@outlook.com

What This Is

This package holds three custom storage and accelerator hardware designs plus one software product under the Cri-One brand. Each hardware design is self-contained with its own KiCad project, datasheets, mechanical drawings, and architecture notes; the software product is a working pure-Python reference implementation.

Why this is L2, not L0

The audit tool's automatic maturity inference initially rated this project L0 because it weighted top-level files. The substantive engineering lives in the three subfolders:

• KiCad schematic files (.kicad_sch, .kicad_sym, .kicad_pro, .kicad_prl) for the 2.5" Vault — that's real PCB design
• Bills of materials (bom.csv, bom-tentative.csv) for all three
• Architecture, mechanical, power, datasheet-hunt documentation per sub-project
• Schematic-generator script (_gen_schematic.py) for the Vault
• Python platform files (cri_one_accelerator.py, cri_one_platform.py) for the PCIe card

A buyer or partner reading this can move directly into fabrication for the Vault (JLCPCB-ready), or into FPGA bring-up for the accelerator card. That's L2.

USPTO Patent Status

No specific application is editorially linked to these designs yet. As hardware originally conceived alongside the AutoPhi family, they may relate to the umbrella application 19/540,453 ("Integrated Technology Portfolio") — verify scope before claiming coverage. See canonical ../PATENT_PORTFOLIO.md.

Quick navigation

For full details on each design, read the sub-project READMEs directly:

• cri-one-2-5-vault/README.md — most ready to fabricate
• cri-one-l3-ssd/README.md — design exploration; bridge chip selection
• cri-one-pcie-accelerator/README.md — accelerator + SSD card
• cri-one-pcie-accelerator/QUICKSTART.md — bring-up steps
• cri-one-software-for-data/README.md — Software for Data, runnable reference implementation
• cri-one-software-for-data/ARCHITECTURE.md — cartridge format, array protocol, corpus citation map
• sales-pitches/businesscartridge26_STORE_PRODUCT_DESCRIPTION.html — storefront listing for Cri-One Software for Data

Maturity Notes (L2 → L3 path)

To move from L2 (Designed) to L3 (Prototyped):

1. Vault: Order the JLCPCB-ready PCB and assemble; benchmark the USB 3.2 Gen 2x2 bridge throughput against the M.2 NVMe SSD spec

2. L3 SSD: Lock in the SATA-to-managed-NAND bridge chip selection (datasheet-hunt.md), then move from bom-tentative.csv to a full BOM and KiCad schematic

3. PCIe accelerator: Build the FPGA bitstream from the open toolchain, run the bring-up sequence in QUICKSTART.md, validate PCIe enumeration on a host system

Contact

Christopher Gabriel Brown

1341 Wellington Cove, Lawrenceville, GA 30043-5255, USA

Email:: crioneaka@outlook.com

Email: crioneaka@outlook.com

42 - Software Driven Ssd

42 - Software Driven Ssd

> Internal playbook -- not for public eyes.

> Last scaffolded: 2026-05-11

1. Identity

2. One-liner

> This package holds three custom storage and accelerator hardware designs plus one software product under the Cri-One brand. Each hardware design is self-contained with its own KiCad project, datasheets, mechanical drawings, and architecture notes; the software product is a working pure-Python reference implementation.

*(Edit this once. It becomes the single sentence you reuse in replies,

on the catalog page, and at the top of any future write-up.)*

3. What's actually in the folder

• cri-one-software-for-data/ (8 entries)
• sales-pitches/ (2 entries)
• 1 light trigger.txt
• CHANGELOG.md
• Contact Information.txt
• CONTACT_INFO.txt
• cri-one-software-for-data.zip
• google_patents_search_list.txt
• MANIFEST.json
• PLAYBOOK.md
• README.md
• Yesterday.txt

4. README at a glance

Top sections found in README.md:

• What This Is
• Why this is L2, not L0
• USPTO Patent Status
• Quick navigation
• Maturity Notes (L2 → L3 path)
• Contact

(Full text: D:\special\42-software-driven-ssd\README.md)

5. Hook lines (pick the one that fits the reader)

• (default) This package holds three custom storage and accelerator hardware designs plus one software product under the Cri-One brand. Each hardware design is self-contained with its own KiCad project, datasheets, mechanical drawings, and architecture notes; the software product is a working pure-Python reference implementation.
• (skeptic / 'what is this really?') TODO -- one honest sentence about

what's solved here that wasn't before.

• (buyer's-finance angle) TODO -- pricing/risk framing (zero-upfront,

4-step credit-forward, revenue share if applicable).

• (competitor question) TODO -- the one comparable product or approach

this most often gets confused with, and the one-sentence delta.

6. Reply patterns

When inbound lands, fall back to the cross-portfolio patterns in

D:\special\manager\emails\PLAYBOOK_software_for_data.md (sections 5

and 8 are reusable across every project) and adapt the specifics.

The product-specific bits to fill in here (TODO):

• One objection unique to this project + the honest answer
• One pricing anchor unique to this project
• One reason to walk away that's worth saying out loud

7. Status & gaps

• Vault: OWN -- project-specific archive ready
• Catalog presence: TODO -- search cri-one.com/store for this product

and paste the live URL here.

• PoF readiness: TODO -- is there a working demo / sample / proof a

prospect could run in under an hour?

• NDA-gated technical brief: TODO -- written? not written? where?
• Critical missing piece before this can close: TODO.

8. Quick links

• Folder: D:\special\42-software-driven-ssd\
• Catalog (cri-one.com): TODO
• Related projects in portfolio: TODO (cross-reference here once mapped)

*This scaffold was auto-generated. Replace TODOs as you learn each project

better. Search across all playbooks: grep -ri "<term>" D:\special\\PLAYBOOK.md

Cri-One Software for Data — Architecture

Cri-One Software for Data — Architecture

This document specifies the binary cartridge format, the Collaborative RAID array

protocol, the conflict-resolution semantics, and the recall protocol. It also

provides the citation map back to the Buy Invent A1–A1752 corpus that anchors

each design decision.

1. Domain model

                  Software for Data runtime
                            │
            ┌───────────────┼────────────────┐
            ▼               ▼                ▼
     CollaborativeArray  RecallEngine   MCIAUChannel
            │               │                │
            └───────┬───────┴────────────────┘
                    ▼
                Cartridge (.sfd file)
                    │
        ┌───────────┼─────────────┐
        ▼           ▼             ▼
     Manifest  ScenarioBlock  LicenseEnvelope
                    │
               ┌────┴────┐
               ▼         ▼
            Payload   Embedding

A scenario is the unit of work. It bundles:

• A payload (bytes — text, structured data, embeddings the recipient should query)
• A vector embedding (for recall / RAG)
• A manifest entry (id, schema, write-tagging, integrity hash, offset)

A cartridge is a sealed file containing N scenarios, an integrity Merkle tree,

a license envelope, and a manifest. Cartridges are the unit of redundancy and the

unit of commerce.

A Collaborative RAID array is M cartridges where K hold scenario data and (M-K)

hold parity. The array tolerates double cartridge loss without losing scenarios.

2. Cartridge file format (.sfd)

All multi-byte integers are little-endian. All UTF-8.

Offset   Size   Field                           Notes
0x000    9      Magic                           b'CRIONESFD'
0x009    2      Format version (uint16)         0x0001
0x00B    16     Cartridge UUID                  Random per cartridge
0x01B    8      Scenario count (uint64)
0x023    32     Master key salt (random bytes)  Used to derive per-scenario keys
0x043    32     License envelope hash           SHA-256 of license envelope
0x063    32     Merkle root over all scenarios  SHA-256 root
0x083    8      Manifest offset (uint64)
0x08B    8      Manifest length (uint64)
0x093    8      Scenario block offset (uint64)
0x09B    8      Scenario block length (uint64)
0x0A3    8      License envelope offset (uint64)
0x0AB    8      License envelope length (uint64)
0x0B3    13     Reserved (must be zero)
0x0C0    ...    Manifest section
                Scenario blocks
                License envelope section
0xEND    32     Footer: HMAC-SHA256 of header   Keyed by master key

2.1 Manifest section (CSV-styled — A41)

The manifest is a CSV-like UTF-8 text block. The CSV-styled choice is direct prior

IP from A41: *"comma separated encryption — strange brew is only a reason to

understand that everyone is csv. styled now."*

scenario_id,a_number,actor,role,offset,length,embedding_offset,embedding_length,integrity_hash
00000001,A1,human,seed,4096,1234,5330,256,a1b2c3...
00000002,A2,human,seed,5586,876,6462,256,d4e5f6...
...

Fields:

• scenario_id — zero-padded sequential ID within the cartridge
• a_number — corpus citation if the scenario derives from a Buy Invent entry
• actor — human, ai, or joint (write-tagging, see §4)
• role — seed, proposal, merge, revision
• offset, length — payload location within scenario block
• embedding_offset, embedding_length — embedding location
• integrity_hash — SHA-256 of plaintext payload + embedding

2.2 Scenario block

Each scenario is stored as:

[2 bytes]  Block magic        b'SC'
[16 bytes] Scenario UUID
[4 bytes]  Payload length
[N bytes]  Payload (encrypted, see §3)
[4 bytes]  Embedding length
[M bytes]  Embedding (encrypted)
[32 bytes] HMAC-SHA256 of plaintext (integrity boundary)

2.3 License envelope section

See src/sfd/license.py. The envelope is JSON over UTF-8, encrypted with the same

format-doubling scheme as scenarios. It carries:

• cartridge_uuid (matches header)
• license_id
• licensee (string)
• valid_from, valid_until (UNIX epoch)
• kill_switch_required (bool — if true, runtime calls kill_switch_endpoint before

any read; receiving a revoke response refuses decryption)

• kill_switch_endpoint (URL, optional)
• revocation_signature (set if revoked)
• royalty_terms (free-form structured)

The kill-switch design is direct prior IP from A1239–A1243:

"data code kill switch agreement and operation adjustment cooperation" and

*"a pr-emptive agreement in a cloud data-base environment that protects the entity

of itself by control and data code kill switch script."*

3. Format-doubling encryption envelope (A376)

Per A376: *"securing and encryption by way of format doubling for example this

format is encrypted then this format is translated into this file format to read."*

The envelope has two layers:

Layer 1 (inner — per-scenario):

• Per-scenario key: K_scen = SHAKE256(master_key || cartridge_uuid || scenario_uuid, 32)
• Keystream: KS = SHAKE256(K_scen || nonce, len(plaintext))
• Ciphertext: plaintext XOR KS
• Integrity: HMAC-SHA256(K_scen, plaintext) appended

Layer 2 (outer — per-cartridge):

• The CSV-styled manifest is itself encrypted with a manifest key:

K_manifest = SHAKE256(master_key || cartridge_uuid || b"manifest", 32)

• Footer HMAC keyed by K_manifest

Why two layers: The CSV manifest is always-encrypted, so an attacker without

the master key cannot enumerate scenario IDs or compute offsets. The per-scenario

keys are derived such that revealing one does not reveal others (forward / backward

secrecy across scenarios). License revocation can rotate the manifest key without

re-encrypting scenarios.

Reference-implementation note: The keystream construction (SHAKE-256 XOR) is

pedagogically clear and uses Python stdlib only. Production deployments should

use cryptography library AES-256-GCM with a separate nonce per scenario.

4. Conflict resolution — human + AI write tagging (A1229)

Anchor: A1229. *"Mission Critical Application Unit (MCIAU) is an instructional

application software that tells the AI what to do and how to do it with a logical

back up and or RAID ability to operate code and instructions by architectures."*

Every write to the array carries an actor tag:

class Actor(Enum):
    HUMAN = "human"
    AI = "ai"
    JOINT = "joint"

When two writes target the same scenario_id in overlapping logical time, the

runtime applies a conflict policy. The default policy is HumanOverride:

Critical invariant: No conflicting write is silently dropped. Every conflict

results in either an explicit merge or a preserved fork. The runtime's storage

guarantee includes "no silent loss across conflicts."

The MCIAU instruction-channel (src/sfd/mciau.py) is the AI-side API for proposing

writes and receiving conflict-resolution callbacks. It implements the A1229 thesis

literally: instructional software tells the AI what to do, and a RAID-backed log

preserves both the instruction and the AI's response.

5. Collaborative RAID array protocol

5.1 Geometry

An array is M cartridges with the layout:

Cartridge 0:  scenarios 0, M, 2M, ...      (data shard)
Cartridge 1:  scenarios 1, M+1, 2M+1, ...  (data shard)
...
Cartridge K-1: scenarios K-1, ...           (data shard)
Cartridge K:   parity P0                    (parity shard)
Cartridge K+1: parity P1                    (parity shard, double-failure tolerance)

For a 5-cartridge array with K=3 data shards and 2 parity shards, the array

tolerates loss of any 2 cartridges without scenario loss.

5.2 Erasure coding

Per A1647–A1650 (quantum-RAID processing / memory / service / scale stack):

We use a simple two-parity scheme:

• P0 = XOR of all data shards (recovers any single failure)
• P1 = XOR of cyclically-shifted data shards (recovers when combined with P0

any double failure)

This is RAID-6 in spirit but operates on scenario chunks rather than disk blocks.

A scenario chunk is the smallest unit of erasure coding — one chunk contains one

scenario's manifest entry + payload + embedding + integrity hash.

The shift parameter and the chunk size are tunable in src/sfd/erasure.py. For

the reference implementation, we use a fixed 4 KiB chunk size and a single-byte

cyclic shift for P1.

Reference-implementation note: Production implementations should use

Reed–Solomon over GF(2^8) for arbitrary parity-shard counts. The XOR scheme here

is correct for K ≤ 2 parity shards but does not generalize.

5.3 Hot add / subtract

Per A246: *"raid multi sd flash card device — raid multiple compact flash

card holder drive addition and subtract able device."*

Adding a cartridge to an array:

1. Append the new cartridge file to the array directory

2. Update array.json to bump M and reassign shards

3. The runtime restripes scenarios in the background

4. Until restripe completes, reads use the old geometry; writes use the new

Removing a cartridge:

1. Mark the cartridge "draining" in array.json

2. The runtime moves scenarios off the draining cartridge

3. When drain completes, the cartridge is released

5.4 Rebuild

When a cartridge fails (missing file, corrupt header, integrity-hash mismatch on

read):

1. The runtime marks the cartridge "failed" in array.json

2. A rebuild job allocates a replacement cartridge

3. For each scenario whose data shard lived on the failed cartridge, the runtime

reconstructs it from the surviving data shards + parity shard(s)

4. During rebuild, reads succeed from the parity-reconstruction path

5. Critical invariant: A second failure during rebuild does not cascade. The

double-parity (P0 + P1) means we can tolerate a second failure mid-rebuild;

conventional RAID-6 implementations break here, which is exactly what the

storefront calls out.

6. Recall protocol (A385–A390, A1437–A1440)

Per A385–A390: *"per-built selects for real-time issue management, using

technology and real life scenarios."*

Per A1437–A1440: *"AI and learning drone... is a bot operated drone that is

computed to navigate and report with a prepared version of a given set of scenarios."*

The recall engine maintains an in-memory index:

class RecallIndex:
    embeddings: list[tuple[scenario_id, embedding_vector]]

    def search(query_embedding, k=5) -> list[(scenario_id, score)]:
        # Cosine similarity, top-k

The reference implementation uses pure-Python cosine similarity. A production

deployment running on the Cri-One PCIe Accelerator would offload this to the

RISC-V cores or DSP block on the FPGA — see ../cri-one-pcie-accelerator/.

7. Buy Invent corpus citation map

Each module of the reference implementation is anchored to specific entries in

the inventor's prior IP corpus.

The product as a whole is anchored on A649. Every architectural decision can

be traced back to a 2017–2019 entry in the inventor's prior IP. This is the

freedom-to-operate posture the storefront listing names.

8. What the buyer gets

When a buyer takes delivery under the storefront's purchase terms, they receive:

• The full source tree of cri-one-software-for-data/ (this directory)
• The Architecture Specification (this document)
• The format and protocol specifications (docs/ will hold the formal IETF-style

specs in a future revision; for v1 they are inlined here)

• A pre-built reference array exercising every demo
• The complete Buy Invent A1–A1752 corpus loader and reference cartridges
• Worldwide commercialization rights for the format, envelope, protocol, and

reference implementation

• No intellectual property is conveyed. See ../sales-pitches/businesscartridge26_STORE_PRODUCT_DESCRIPTION.html

for full terms.

Cri-One Software for Data

Cri-One Software for Data

> Software for data — the kind that doesn't lose what it stores, that lets people

> and AI work on the same scenarios at the same time, and that can be packaged,

> shipped, and resold as a unit.

Parent package: ../README.md (Software-Driven SSD — Cri-One Storage Hardware Family)

Storefront listing: ../sales-pitches/businesscartridge26_STORE_PRODUCT_DESCRIPTION.html

Source IP corpus: ../1 light trigger.txt (Buy Invent A1–A1752, © 2017–2019 Christopher G. Brown)

Inventor / Licensor: Christopher Gabriel Brown — crioneaka@outlook.com — 770-776-7023

What this is

A working reference implementation of Cri-One Software for Data — pure Python,

standard library only, no external dependencies. It demonstrates every capability

claimed in the storefront listing on real bytes:

Each .py file is heavily commented and cites the Buy Invent A-number that anchors

the design choice. See ARCHITECTURE.md for the full corpus

citation map and the binary format specifications.

Quickstart

Requires Python 3.10 or later. No pip install step — stdlib only.

# From this directory:
cd cri-one-software-for-data

# Run all demos in order:
python demos/demo_01_build_cartridge.py
python demos/demo_02_build_array.py
python demos/demo_03_silent_corruption.py
python demos/demo_04_double_failure_rebuild.py
python demos/demo_05_human_ai_conflict.py
python demos/demo_06_hot_add.py

# Run the test suite (note: PYTHONPATH=src so unittest discovery finds the package):
PYTHONPATH=src python -m unittest discover tests -v

# Real AI agent (optional — requires the [agents] extra and an API key):
pip install -e ".[agents]"        # adds anthropic + pydantic
export ANTHROPIC_API_KEY=sk-...
PYTHONPATH=src python demos/demo_07_real_ai_agent.py

# Use the CLI (also needs PYTHONPATH=src):
PYTHONPATH=src python -m sfd.cli --help
PYTHONPATH=src python -m sfd.cli build-cartridge --corpus "../1 light trigger.txt" --limit 25 --output sample.sfd
PYTHONPATH=src python -m sfd.cli inspect sample.sfd
PYTHONPATH=src python -m sfd.cli recall sample.sfd --query "raid for ai"

On Windows PowerShell, use $env:PYTHONPATH = "src" instead of the inline form.

After pip install -e ., the sfd console script becomes available without

PYTHONPATH (see pyproject.toml).

Layout

cri-one-software-for-data/
├── README.md                       (this file)
├── ARCHITECTURE.md                 (binary format, protocol, corpus citation map)
├── pyproject.toml                  (Python packaging metadata)
├── src/sfd/
│   ├── __init__.py
│   ├── manifest.py                 (scenario manifest schema — A41 CSV-styled)
│   ├── envelope.py                 (format-doubling encryption envelope — A376)
│   ├── cartridge.py                (cartridge writer / reader — A1059, A246)
│   ├── erasure.py                  (scenario-level erasure coding — A1647-A1650)
│   ├── array.py                    (Collaborative RAID array — A222, A234, A1229)
│   ├── conflict.py                 (human / AI write tagging — A1229)
│   ├── mciau.py                    (AI instruction channel — A1229 verbatim)
│   ├── license.py                  (license envelope + kill switch — A1239-A1243)
│   ├── recall.py                   (RAG primitive over scenarios — A385-A390, A1437-A1440)
│   ├── corpus.py                   (Buy Invent A1-A1752 loader)
│   └── cli.py                      (sfd command-line tool)
├── tests/
│   ├── __init__.py
│   ├── test_core.py                (cartridge, envelope, manifest invariants)
│   ├── test_array.py               (array, erasure, double-failure rebuild, hot-add)
│   ├── test_conflict.py            (human/AI write tagging, MCIAU instruction channel)
│   └── test_recall.py              (recall + corpus loader)
└── demos/
    ├── demo_01_build_cartridge.py  (build one cartridge from Buy Invent corpus)
    ├── demo_02_build_array.py      (build a 5-cartridge Collaborative RAID array)
    ├── demo_03_silent_corruption.py
    ├── demo_04_double_failure_rebuild.py
    ├── demo_05_human_ai_conflict.py
    └── demo_06_hot_add.py

Status

Maturity: L2 (Designed) → L3 (Prototyped) — runnable reference implementation.

Per ../../PACKAGE_ARCHITECTURE.md, L3 means a working

prototype that exercises the design end-to-end. The demos prove this.

Not in scope for v1 reference:

• Production-grade cryptography (we use SHAKE-256 keystream + HMAC-SHA256 — fine for

reference; production should use cryptography library AES-GCM)

• Real LLM embeddings (we use a deterministic n-gram hash — fine for protocol; a

production buyer plugs in their own model)

• C / Rust runtime (Python is the reference; C is the next deliverable)
• FPGA / ASIC offload to the Cri-One PCIe Accelerator (separate sub-project)
• Marketplace UI / billing / royalty payouts (the schema is delivered; the UI is buyer-built)

License posture: This source tree is sold under a commercial source license

— see LICENSE.md for the full grant. Summary:

• What the buyer owns after the sale: the complete cri-one-software-for-data/

source tree as delivered, plus every modification, fork, and derivative work the

buyer creates. Run, modify, redistribute, sublicense, and incorporate into

commercial offerings — perpetually, worldwide, royalty-free.

• What the licensor retains: (1) the Buy Invent A1–A1752 corpus

(1 light trigger.txt), © 2017–2019 Christopher G. Brown — referenced for

provenance only via A-number citations; not part of the distribution. (2) Any

patent that may issue from the method-claim filing (possible umbrella coverage

under US 19/540,453). (3) The "Cri-One" and "Buy Invent" trademarks.

• What ships in lieu of the corpus: sample_corpus.txt —

25 synthetic entries in the same format so demos and tests run out of the box.

See the storefront listing

for the full purchase terms and the LICENSE.md for the operative

license text.

Cri-One Software for Data — Magento Product Card

Cri-One Software for Data — Magento Product Card

Everything you need to create the product entry on cri-one.com/store/. The

long description (HTML) is in

businesscartridge26_STORE_PRODUCT_DESCRIPTION.html;

this file covers every other field on the Magento product form.

Catalog metadata

Short description (Magento "Short Description" field — appears in catalog tiles)

> Software for data that doesn't lose what it stores, that lets people and AI

> work on the same scenarios at the same time, and that ships as a portable,

> sealable cartridge format. Sold as the complete cri-one-software-for-data/

> source tree under a commercial source license — perpetual rights to run,

> modify, fork, redistribute, and incorporate into your own products.

> Buy Invent A1–A1752 corpus and method-claim patent strategy retained by

> the licensor. US $1,000,000,000.

Long description

Paste the contents of

businesscartridge26_STORE_PRODUCT_DESCRIPTION.html

into the "Description" field via Show/Hide Editor → HTML source view.

SEO fields

Image

See the Image prompts section below for AI-generation prompts.

Recommended additional fields

Image prompts (Adobe Firefly — primary, plus two alternatives)

The visual brief: serious, businesslike, neutral palette to match the Arial /

grey "boring and real" aesthetic of the storefront listing. No AI-art

tropes (no purple gradients, no glowing orbs, no robot hands reaching for

human hands). The image should look like it belongs in a 1970s IBM product

brochure or a Bloomberg Terminal manual.

Primary prompt — documentary product photography

Use this in Firefly with Style: Photo, Aspect ratio: Square (1:1),

Visual intensity: Subtle, Color: Muted, Lighting: Studio:

> Top-down studio photograph of five small rectangular dark-grey storage

> cartridges arranged in a clean horizontal row on a brushed-steel surface.

> Each cartridge is identical, about the size of a deck of cards, with a

> matte charcoal finish and a tiny embossed serial number on its side. The

> two cartridges in the middle of the row are very slightly raised, casting

> a soft shadow, suggesting they are active. The leftmost cartridge has a

> small paper card tucked alongside it, written in fountain pen — illegible

> handwriting, just visible enough to read as human-authored. The rightmost

> cartridge has a faint printed-circuit-board pattern etched into its top.

> Soft cool studio lighting from above, no harsh shadows. Neutral palette:

> brushed steel, charcoal, off-white, ink black. Editorial product

> photography in the style of a serious enterprise-software product

> brochure. Sharp focus throughout. No people, no text overlay, no logos,

> no glowing elements.

What this evokes: the five-cartridge Collaborative RAID array, with a

subtle suggestion of human + AI co-authorship via the paper card and the

PCB pattern. The matched cartridges signal the redundancy. The brushed

steel and ink-black palette match the storefront's grey aesthetic.

Alternative 1 — patent-drawing isometric line art

Use this with Style: Art, Content type: Vector art, Aspect ratio: Square,

Color: Black and white:

> Black-on-cream isometric line drawing of five rectangular storage

> cartridges arranged in an array, in the style of a 1970s utility patent

> figure. Crisp dark-ink outlines, fine cross-hatching for shading, no

> color. Each cartridge is labeled with a small enclosed-circle reference

> numeral: 1, 2, 3, 4, 5. Two short label lines extend off the array, one

> labeled "scenario shard," one labeled "parity shard." The drawing is

> centered on a faintly visible grid-paper background, the kind that

> appears in inventor's-notebook scans. Title block in the lower right

> corner reads "FIG. 1 — REDUNDANT CARTRIDGE ARRAY" in serif type. Crisp,

> draftsman quality. No people, no decoration, no color, no glow.

What this evokes: the patent-anchored character of the product, the

inventor's-notebook origin of the corpus, and the technical-spec posture

of the storefront listing.

Alternative 2 — editorial still life

Use this with Style: Photo, Aspect ratio: Square (1:1),

Lighting: Natural, Color: Warm muted:

> Editorial still-life photograph on a worn dark walnut writing desk: a

> single small dark-charcoal storage cartridge sits next to an open cream

> hardcover ledger with a fountain pen resting in the gutter, a folded

> handwritten paper note tucked under the cartridge, a stoneware coffee

> cup just out of focus in the background. The handwriting on the note is

> too small to read but clearly human. Window light from the upper left,

> soft, late afternoon. Neutral palette dominated by charcoal, dark

> walnut, cream, with a single muted ink-blue accent on the fountain pen.

> Composition is asymmetric, the cartridge slightly off-center to the

> left. Editorial business-magazine photography, sharp on the cartridge

> and ledger, soft on the cup. No people visible, no text or logos

> readable.

What this evokes: the inter-business document-exchange use case (M&A

data rooms, regulatory filings, legal submissions). The handwritten note +

ledger + fountain pen all anchor the human-authored side; the cartridge

sits in the middle of that workflow.

Negative prompt (use in any generator that supports them)

Add the following to the "Avoid" / negative prompt field:

> AI-art clichés, purple gradients, glowing orbs, neon, holograms, robot

> hands, human hands reaching toward technology, abstract energy beams,

> circuit-board glow, futuristic city skylines, cyberpunk lighting,

> volumetric haze, lens flare, motion blur, blurred faces, partial people,

> hands, fingers, generic AI-product splash art, cookie-cutter SaaS hero

> imagery, stock-photo people in suits, smiling diverse team meeting,

> pointing at screens, generic data-center server-rack imagery, tangled

> cables, datacenter aisles, generic database storage shelves, wireframe

> humans, brain-with-circuits, abstract neural-network illustration,

> trading-floor screens, sci-fi UI panels, glowing 1s and 0s, generic

> "data" wallpaper.

Aspect ratios for Magento

You can generate all sizes from the same square hero by Magento's auto-resize

or by exporting from Firefly at multiple aspect ratios.

Suggested deploy order

1. Generate the image with the primary prompt above. Iterate 4-6 generations

in Firefly, pick the strongest, do final color/contrast tweak in any image

editor.

2. Save as cri-one-software-for-data.jpg (1200×1200 minimum).

3. In Magento admin → Catalog → Products → Add Product → Type: Simple Product

(or Virtual, since it has no shipping).

4. Fill the catalog metadata fields above.

5. In Description: Show/Hide Editor → paste contents of

businesscartridge26_STORE_PRODUCT_DESCRIPTION.html.

6. Upload the image, set roles (Base / Small / Thumbnail / Swatch).

7. Fill SEO fields.

8. Save & publish.

9. Verify the storefront page in an incognito window:

https://cri-one.com/store/cri-one-software-for-data-no-ip.html

© 2026 Christopher Gabriel Brown. All rights reserved.

---

This archive contains 5 documents. The complete folder ships as the product.