# PicoSuite

## A bounded, capability-oriented platform from bare metal to browser and local AI

**Technical whitepaper | Repository evidence reviewed 20 November 2026**

### Executive summary

PicoSuite is an integrated platform, not an application name. It brings together a bare-metal operating system, reusable native libraries, a bounded scripting runtime, identity services, a dependency-free browser toolkit, local productivity applications, and an emerging hardware-backed AI execution stack.

Its central proposition is **to make resource ownership and execution costs explicit across the whole system**. The OS owns devices, transport and memory authority. Applications express policy through PicoScript and consume capability-gated services. PicoWAL provides compact durable state. PicoWeb supplies native web-serving and application-route components. BareMetalJsTools supplies browser interfaces without a framework runtime. DaveAI is a demanding consumer of those foundations, not a special privilege inside the kernel.

The approach is different from assembling a conventional Linux/container/web-framework stack, but it does not eliminate the engineering responsibilities that stack normally absorbs. PicoSuite takes direct responsibility for scheduling, interrupt continuation, storage recovery, protocol interoperability, cryptography integration, accelerator visibility, and safe cancellation.

**Current assessment:** substantial foundations and component-level proofs exist. The Pi 5 kernel has recorded hardware operation; the browser toolkit and several native libraries have extensive implementation; application and model-service contracts are present. However, a fully integrated, authenticated, recoverable PicoSuite appliance with productive app capsules, replicated cluster services and repeatable GPU model serving has not yet met its end-to-end acceptance gates. It is best described as an **advanced engineering platform with uneven component maturity**, not a completed production suite.

The shortest credible path forward is to close ownership and reproducibility gaps, prove one authenticated application/storage vertical slice, establish repeatable CPU model execution, and then graduate guarded GPU operations into a safe resident-model service. Cluster automation and the wider application catalogue should build on those proven seams.

---

## 1. Scope and evidence

This paper examines the local `WillEastbury/SmoofOS` monorepo. The repository name is historical; the platform name is **PicoSuite**. Its bare-metal component is the **PicoSuite OS Kernel**, retained under `components/pios`. SmoofSuite-derived applications are currently represented by **PicoDesk** under `components/picodesk`, plus the separate target application capsules under `apps`. There is no `components/smoofsuite` directory in the inspected checkout, despite older manifest and overview references. [1][2][3]

The initial review began at commit `b1c97e3ce852f16120960a97c9c3ddbec2288700`, with uncommitted kernel/storage/test changes, an updated DaveAI text-API document, and a new model uploader in the working tree. Those changes were subsequently committed as `bf729cf7843638f37fe158cc29d0337b7f10fc6b`, the baseline for the follow-up searches. This is a **research snapshot**, not certification of an immutable release. Repository source, current contracts, dated execution records, hardware gates and current GitHub issue status were inspected. No new kernel or component build, platform benchmark, deployment or hardware experiment was performed for this paper.

Evidence is distinguished throughout:

| Evidence level | What it establishes | What it does not establish |
|---|---|---|
| Source or contract present | An implementation or defined interface exists | Successful execution or integration |
| Host fixture/reference | Checked behavior with host execution, often simulated devices | Physical interrupts, DMA, storage durability or deployment |
| QEMU integration | Guest boot and the particular exercised guest path | Pi 5 peripheral behavior or discrete GPU execution |
| Physical bounded proof | The recorded operation worked on that image/device | General workload support, safe reuse or recovery |
| Release acceptance | Reproducible regression and all applicable hardware gates pass | Implied by none of the levels above |

The active **kernel** support targets are Raspberry Pi 5 and QEMU AArch64 `virt`. Other Pi boards, Hyper-V and native x86 kernel ports remain historical, out-of-scope experiments. This policy does not remove the Windows/Linux portability of individual libraries, nor the Linux implementation of PicoCluster. [4]

Older documents are not uniformly current. Examples include the libraries overview calling PicoLog/PicoPXE unimplemented and the model-cli README calling the port a scaffold. Where these conflict with inspected source, later execution notes or current issue status, the more specific evidence takes precedence. [5][23][32]

## 2. What is different

### 2.1 A common engineering discipline across layers

The differentiator is not one novel queue, database or UI widget. It is the attempt to preserve a common set of rules from device execution to application delivery:

- Bounded memory, work, queues and parsing.
- Explicit owner, generation and lifetime for reusable resources.
- Immutable publication across ownership boundaries.
- Capability checks before protected work is decoded or materialized.
- Backpressure instead of overwriting outstanding work.
- Observable failure rather than a successful-looking fallback.
- Separation of application policy from OS and device authority.

These mechanisms already appear in the service FIFO, portable storage engine, route table, tensor descriptor broker and DaveAI stream prototype. Their existence does not mean every active legacy path has converged on them. Convergence is an explicit remaining engineering task. [6][8][9][18][25][32][35]

### 2.2 Owning the OS rather than merely tuning a host

PIOS runs without Linux or a POSIX environment in the kernel. Core 0 is reserved for kernel I/O and management; cores 1-3 run preemptively scheduled user processes. Hardware-specific drivers sit behind common contracts.

This gives the project direct control over its data path and recovery behavior. The tradeoff is direct ownership of work normally supplied by a mature OS: device bring-up, page attributes, interrupt routing, protocol correctness, filesystem recovery and debugging tools. "Deterministic" should be understood here as a design objective enforced through bounds and ownership, **not a demonstrated whole-system hard-real-time guarantee**. [4][6][7]

### 2.3 Pay predictable costs early

PicoWeb's Linux static-serving path reads or maps assets, builds response variants and constructs lookup tables at startup. Its hot path is lookup plus resumable send rather than repeated allocation, formatting and file assembly.

The same reasoning appears in fixed queue capacity, caller-owned library buffers, compiled PicoScript policy and resident AI weights. Predictability is gained by moving work to initialization or explicit preparation, at the cost of capacity planning and update/rebuild mechanics. Static-serving claims do not extend to every dynamic application, TLS or storage path. [8]

### 2.4 Small, independently usable components

PicoSuite libraries and BareMetalJsTools can be used without adopting the bare-metal OS. The browser toolkit is plain JavaScript and CSS; the portable database and search libraries accept caller-owned memory; PicoCluster deliberately uses small native Linux processes rather than an OCI container ecosystem.

This makes adoption incremental. It also means "PicoSuite runs without dependencies" is too broad: browser modules have no runtime package dependencies, the kernel is freestanding, Linux services use libc and OS facilities, and optional media workers may still require Python/Torch/Diffusers. [5][8][10][11][23]

### 2.5 AI as an OS service, not browser or kernel branding

The intended model interface lets a capsule open an authorized logical model and request execution without naming a GPU, DMA pointer or physical address. Native providers own arithmetic and execution. PicoScript supplies control policy. DaveAI handles the user-facing conversation and application orchestration.

The separation allows independent UI and inference deployment and, eventually, provider selection based on compatible operation contracts. It does not yet establish runtime-interchangeable Falcon CPU/QPU/B50 execution or a heterogeneous production scheduler. [18][23][26][27]

These are architectural differentiators, not claims of uniqueness, formally proven isolation, lower total cost, or superiority to established products. Those claims would require comparative measurements and independent assurance.

## 3. System architecture

### 3.1 Platform layers

```text
 Browser clients
   BareMetalJsTools: UI, documents, workflows, storage, transport
          |
 Application tier
   PicoDesk / app capsules             DaveAI frontend and orchestration
          |                                      |
          |                         Versioned inference API (remote seam)
          |                                      |
 Service and runtime contracts
   PicoSTS/PicoLogin | PicoScript | PicoWeb routes | Model service
   Storage, discovery, deployment and cluster service contracts
          |
 Reusable native libraries
   PicoWAL | search | compression | crypto | Parquet | small domain APIs
          |
+--------------------------+-----------------------------------------+
| PIOS implementation      | Native-host implementations             |
| EL0 capsules             | Linux PicoWeb/PicoCluster               |
| OS-owned FIFO/span IPC   | Windows/Linux library and DaveAI hosts  |
| Core-0 I/O + drivers     | OS sockets/files/process adapters       |
+--------------------------+-----------------------------------------+
          |
 Pi 5: ARM/NEON, VideoCore, SD, Ethernet, PCIe/NVMe/experimental Arc
 QEMU: virtual ARM CPU, virtio network/block devices, framebuffer
```

This is a responsibility map, not a claim that every box is wired into one running system. In particular, the Linux supervisor is not a bare-metal component, and remote inference HTTP is not the local FIFO ABI. [1][10][12][26]

### 3.2 Kernel execution and the fail-safe path

On Pi 5, hardware IRQ top halves acknowledge or quiesce the device and publish bounded work. Protocol processing follows scheduled **IRQ -> FIFO -> AIRQ -> subsequent FIFO stage** handoffs, not timer-driven protocol polling.

`airq` separates software priorities and producer/target lanes. `adrv` provides admitted, deadline-bounded asynchronous driver steps. Queue saturation must retain a continuation until credit returns. A doorbell may coalesce; correctness rests on published work and retained sequence-backed continuation, not on equal interrupt and message counts.

Core 0 is especially important: it owns the network, disk and operator path, and answers requests on which other cores may be waiting. Blocking it can make a live board unreachable and stall the application cores simultaneously. The architecture protects that path, but remaining SD/NVMe/TLS polling migrations show that the objective is not yet universally achieved. [6][7][32]

User processes execute at EL0 with mandatory preemption and private kernel exception stacks. Scheduling supports eligible cores, optional pinning and owner claims. Shared control records are cache-line isolated. A physical page must retain compatible memory attributes across kernel, user and other aliases; ordering barriers cannot repair contradictory cacheability. [6]

### 3.3 Local service IPC

The current service FIFO header defines ABI 2 with 64-byte descriptors, generation and owner metadata, bounded lengths, and release/acquire publication. Producer and consumer indices reside on separate owned pages. Requests and completions are distinct channels; model traffic has an additional independent lane.

The broad pattern is:

```text
Authorized caller -> immutable descriptor -> OS-owned bounded queue
     -> service/provider -> correlated completion -> owner-routed wake
```

No sender-local pointer becomes receiver authority. Borrowed spans and leases remain owned until the relevant consumer, cancellation acknowledgement or safe retirement boundary permits reuse.

Several bridge implementations and specialized model paths coexist. The generic ModelFifo VM registry still lacks its complete production stop/retire/reuse protocol; this must not be confused with the separately implemented capsule model-service FIFO path. Existing local VM queues are likewise not automatically cross-process OS queues. [9][18][19][32]

### 3.4 Boot, storage and updates

A small stage0 loader selects the real OS from redundant raw A/B slots, with checked FAT recovery packaging and controlled override behavior. WALFS supplies the kernel's append/recovery-oriented storage. The exFAT **Transfer** volume is a separate interchange surface, used for files such as model weights.

These are related, but not interchangeable:

- **PicoWAL** is the database/component family.
- **WALFS** is the PIOS filesystem/storage implementation.
- **Transfer/exFAT** provides host-interchange files.
- **PicoDrive CAS** is a proposed immutable-object and revision API above WALFS.

Transfer HTTP uploads are asynchronous: HTTP 202 means queued, not durably committed. Clients must inspect completion status. Exclusive writer leases prevent model readers or competing mutations from observing an incomplete upload. Recent storage work is specifically hardening this path. [13][20][28][29]

Pi and QEMU have different raw-slot capacities and memory layouts. A QEMU image or successful direct-boot smoke cannot certify Pi boot-media compatibility or a changed physical stage0 trampoline. [13][29]

## 4. Component technical approach

### 4.1 PicoSTS and PicoLogin: identity with explicit hosting boundaries

Two relevant implementations must be distinguished.

**Native PicoSTS**, under `components/picosts`, provides OIDC discovery/JWKS, authorization-code and refresh flows, password storage, RS256 JWT support, PKCE, TOTP and bounded directory/token stores. It consumes PicoSuite crypto and the portable PicoWAL adapter. Its PicoWeb route plugin uses caller-owned route/response storage; RSA signing requires a configured DER key and fails closed without one. Administrative import remains explicitly unavailable. [14]

**PIOS PicoLogin**, under `services/picologin`, is a PicoScript service using native kernel STS/FIFO bindings. Its documented native signing path is HS256, with Interactive, Background and System identities and resource permissions. Internal identity comes from the bound FIFO source rather than a second HTTP password exchange. [15]

PicoDesk also retains a local development STS prototype. These are not evidence of one fully reconciled production identity deployment. The remaining work is to establish durable provider ownership, verified identity propagation, consistent resource grants and tested revocation across all active paths. Browser RBAC is a UI aid, never the enforcement authority. Current STS/cluster enforcement work remains open. [3][15][32]

### 4.2 PicoWeb: native serving plus an embeddable application seam

The Linux server uses per-worker connection pools, `epoll`, `SO_REUSEPORT`, immutable asset arenas, host/path hashing, prebuilt headers and partial-send state machines. Media can use read-only mappings and Range requests. The portable route table offers exact method/path dispatch independently of that Linux listener.

The adjacent userspace network tree contains real crypto/TLS/TCP implementation and separate QUIC/HTTP-3 primitives. Its own status document distinguishes compiled/tested code from live protocol integration; the running server must not be advertised as HTTP/3-ready merely because those sources exist.

PIOS uses its own network/TLS stack and EL0 capsule adapters. Linux `sendmsg` performance or host TLS features are not inherited automatically by that implementation. [7][8][16]

### 4.3 PicoWAL: compact state with explicit durability

PicoWAL uses packs/cards as a compact data model across embedded and hosted implementations. The portable C11 engine is independently usable: positional storage callbacks, caller-owned primary/index tables, append records, CRC recovery and derived index rebuilds.

Recovery follows the valid append chain and stops at torn or invalid records. The adapter's `sync` callback is the durability boundary. An exhausted derived index is marked incomplete, leaving primary data intact; callers must fall back to a primary scan rather than return incomplete answers as complete.

The portable engine's current transaction unit is one put/delete record. It is not a general multi-record transaction system. Other PicoWAL and WALFS variants have different formats and limits; the appliance's 508-byte card limit and application conventions around 4 KiB must not be generalized to every adapter. [17][20]

### 4.4 PicoScript: bounded policy, native capabilities

The shipped C VM has a compact 16-opcode base instruction set, verification and execution budgets, with host capability classes for protected bindings. The browser compiler/editor and VM assets connect authoring, bytecode, control-flow views and execution tracing.

The useful division is **portable policy above native services**: request handling, routing and orchestration in scripts; networking, secrets, crypto primitives, memory grants and device execution in trusted providers. Generic network hooks exist, but the target app-capsule model uses `Req`/`Resp` and capability services, not independent application-owned sockets.

A hook name, capability bit or generated reference entry does not prove a live PIOS provider exists. Some collection hooks remain local or deferred; device/stream documents include design-only surfaces; newer timer, resident lifecycle, context and telemetry work is still tracked separately.

The canonical compiler/runtime source is not fully represented as one self-contained authoritative tree in this monorepo. Vendored C, generated browser assets, external compiler inputs and local host extensions therefore require exact versioning and differential tests. Typed ownership and retained workflow frontend parity are remaining work, not completed language guarantees. [21][22][19][32]

### 4.5 Other PicoSuite tools

| Family | Technical approach and existing scope | Boundary/readiness qualification |
|---|---|---|
| PicoCompress | Codec-neutral shell/registry; native `micro` codec; one descriptor ABI for static and dynamic registration; streaming conversion | Preserve v3 bitstream and cross-language identity; codec modules, not the host, own format behavior |
| PicoZstd | Caller-owned C11 streaming Zstandard decoder; raw/RLE/compressed blocks and entropy decoding | Decoder-only, dictionary-free v0.1; not a full Zstandard feature implementation |
| PicoParquet | Read-only, selective column reader; bounded metadata/page/dictionary storage; callback input and codec seam | Explicit unsupported encodings/features; not a writer or general analytics engine |
| PicoCrypto | Shared SHA/HMAC/PBKDF2/RSA and constant-time/zeroization helpers | Not a certificate host, key generator or proof of cryptographic assurance |
| Search | Generic PicoWAL inverted/vector substrates; lexical, fuzzy and hybrid assemblies | Caller supplies storage and vectors; no embedding model or automatic Unicode normalization |
| Small domain APIs | PicoJSON, PicoHTTP, PicoCatalog, PicoEvents, PicoRecommend, PicoCart and PicoOrder | Bounded building blocks, not complete JSON/HTTP servers, payments or persisted commerce systems |
| PicoBlob | Native content-addressed PUT/GET/HAS/DEL TCP implementation | Not SMB, replicated storage or the completed PicoDrive API |
| PicoLog | Native append/read/tail service integrated with PicoWeb and external STS validation | Native host implementation differs from the PIOS service integration |
| PicoDNS/DHCP/PXE | Native DNS/registration/anti-entropy, lease and DHCP handling, read-only TFTP boot-file serving | Source and tests exceed older scaffold descriptions; PIOS hosting/netboot remains separate |
| PicoCluster/PicoPod/PicoReplicate | Desired state, placement, replication, process/rootfs isolation and authenticated log exchange | Primarily Linux implementations; cluster safety and production deployment need their own evidence |
| PicoWatch/PicoAI service capsules | PIOS-target metadata routes for watch targets/status and AI models/jobs | Not an implemented health-reconciliation loop or OpenAI-compatible inference endpoint |

The unifying value is reusable, narrow machinery rather than a promise to reproduce every large upstream ecosystem. For example, PicoJSON's extraction helper is explicitly not a validating general parser, and vector similarity is not semantic understanding without a supplied embedding pipeline. [5][10][11][30][31]

The inspected PicoWatch, PicoAI and PicoSearch service scripts illustrate the difference between intent and implementation: they expose health/readiness and pack metadata operations, but do not execute automatic service reconciliation, model inference or ranked search. Their readiness check establishes storage availability, not readiness of those engines. [36]

### 4.6 BareMetalJsTools: the browser half of the platform

The inspected `src` directory contains **113 non-minified `BareMetal.*.js` modules**. This is an inventory count, not a statement that every module is equally mature or loaded by every app.

The toolkit covers reactive binding and controls; schemas and binary transport; charts, grids and documents; workflow/report designers; browser storage and offline outboxes; authentication/session helpers; accessibility; media, audio and terminal interfaces.

Modules attach to the shared `BareMetal` namespace as plain script-loaded IIFEs. Consumers choose what to load and observe dependency order. UI source does not need a framework compilation step, although generating PicoScript assets, minified distributions and integrity manifests still involves tooling.

The browser does substantial UI and local/offline work, keeping the server surface compact. It does not acquire server-side trust through client token decoding, infer model execution from an AI widget, or turn an offline queue into a distributed transaction guarantee. [24]

### 4.7 SmoofSuite-derived tools: PicoDesk today, app capsules tomorrow

PicoDesk is a local office/developer desk using BareMetalJsTools, PicoScript and chunked PicoWAL-style state. Its implemented surfaces include:

- **PicoSheet:** grid, formulas, drawings, filtering and graph/pivot views.
- **PicoWrite:** a small document editor.
- **PicoShow/PicoBase:** slides and form-led records.
- **PicoMail/PicoChat:** local mail tooling and rooms with browser WebRTC signalling.
- **PicoDrive:** file catalogue/chunk operations.
- **Developer/orchestra seat:** board, agents, tasks and file-oriented coding tools.

These are intentionally small local tools, not Office/LibreOffice/Google compatibility products or a public mail/cloud-storage gateway. Native/background Drive sync, Tune playback, Vault autofill and the broader capsule composition are roadmap items.

The distinction is important: the **developer desk is implemented**, while the `apps` target servers for Sheet, Doc, Chart, Chat, Mail, Forge, Drive, Tune, List and Vault are currently boundary stubs. They provide health, require host-validated authentication for other requests, and then return 501. PicoDrive's CAS/revision API is documented but absent from its stub.

A completed-looking browser screen is therefore not evidence that its production capsule API, durable storage and cross-app identity work on PIOS. [2][3][28]

## 5. DaveAI and the hardware execution stack

### 5.1 Application, protocol and engine are separate responsibilities

DaveAI combines a browser workspace, PicoScript API admission policy, native host capabilities, DeveloperCLI/model-cli inference, and optional media/tool workers. Parts of the broader application still use Python orchestration; the native architecture direction is not a claim that migration is finished.

A versioned inference API defines model discovery, job submission, bounded NDJSON output, owner/conversation scope, cancellation, restart behavior and measured telemetry. A reference service and tests establish that seam without requiring working PIOS inference.

The QEMU portal prototype demonstrated actual EL0 asset streaming and real C-VM policy execution. Its dated record reports five API checks and 50 portal/stream checks, including byte identity, slow readers and disconnect recovery. However, it used an isolated kernel overlay; trusted sign-in, production storage, incremental TLS output and real inference were not established by that run. [23][25][26][27]

### 5.2 The native model work is beyond a scaffold

The model-cli port contains tokenizer, GGUF, Qwen and several backend sources, compatibility/memory adapters and independent reference tooling. Later port notes supersede the old "no code ported" README.

The Falcon3-1B-Instruct-1.58bit lane has more concrete integration: authenticated model definitions and chunk hashes, Transfer readers, tokenizer worker protocol, CPU forward execution, compiled capsule calls and real FIFO/broker host fixtures. Host tests have produced exact checkpoint-backed responses through the broker encoder with simulated SD and scheduler events.

A historical incrementally linked QEMU CPU image returned `Hello! How can`; the run asserted a shorter prefix and the full response was manually compared. Clean-image repeatability and overlapping-request runs remained unresolved in later notes. This is limited software execution evidence, not a repeatable deployed service or a physical inference pass. [18][23][29]

### 5.3 Hardware layers and what has actually been proved

| Hardware layer | Role | Recorded evidence and current limit |
|---|---|---|
| Pi 5 ARM CPU/NEON | Kernel, native arithmetic and reference execution | Kernel hardware operation and NEON primitive checks exist; complete physical checkpoint/API acceptance remains open |
| VideoCore VII/QPU | Selected tensor/media offloads | Guarded operations and representative batch profiles exist; generic model execution and Falcon provider interchange are not established |
| PCIe1 and switch fabric | Attach discrete storage/compute | Enumeration/recovery observations exist; discovering an endpoint is not execution authority |
| Intel Arc B50 | GuC/CCS/PPGTT native compute and emerging resident Falcon provider | Guarded stores and a fixed tensor passed; current retirement, physical resident upload and full model gates remain open |
| Intel Arc B60 | Heterogeneous future compute target | Enumeration/capability observations are not a validated B60 model backend |
| NVMe | Higher-capacity/faster storage | A dated namespace block read/write and ring-wrap proof passed; filesystem integration and broader async/recovery acceptance remain distinct |
| SD/exFAT Transfer | Checkpoint interchange and verified source reads | Async source/upload implementation and fixtures exist; interoperability, power-cut and live throughput gates remain |

On 10 November, a guarded B50 PPGTT tensor job matched all 16 outputs, guards and independent completion markers and published its result. The device remained quarantined because retirement/DMA safety was not established. Later runtime lease/fence changes have host tests but need their own physical validation. Earlier failed PPGTT attempts must not erase the later bounded pass; equally, that pass must not be promoted into full inference readiness. [29]

The newer resident Falcon software path wires authenticated Transfer chunks to a generation-owned COPY_U32 uploader, resident projections, GPU KV state, attention and output-head dispatch. A complete forward-state mock covers all 18 layers and 1,366 head tiles. **It proves orchestration wiring, not actual shader execution or generated answers on B50.** [18]

The recorded 18 November preflight found no B50 on the selected node and insufficient Transfer capacity: the three-file model bundle was approximately 1.377 GB, exceeding the approximately 1.333 GB partition by 44.7 MB before filesystem overhead. This is a dated deployment blocker, not a fresh claim about today's board. [29]

### 5.4 Why accelerator completion is not enough

At least four facts must be proved separately:

1. The right operation was admitted for the right owner/model/device generation.
2. The device actually executed correct arithmetic and wrote visible output.
3. The reported completion belongs to that operation, with guards intact.
4. The device can no longer access resources before they are reused.

A timeout, cancellation, completion marker, clear AER status, or disabled bus-master bit is not by itself a resource-reclamation fence. This is the central challenge in converting bounded diagnostic GPU execution into a reusable multi-tenant model service. [18][19][29]

## 6. Engineering challenges and tradeoffs

### Protecting progress under backpressure

Full FIFOs, lost re-arms, slow SD operations or a blocked core-0 callback can stall the entire chain. Tests need to exhaust real pools, retain work, return credit and prove progress without an unrelated timer or packet accidentally waking the system. Current transport convergence and polling-removal issues are directly relevant. [7][32]

### Keeping lifetime, cancellation and recovery consistent

HTTP disconnects, capsule exit, worker loss, device generations and storage leases must agree about who still owns memory. "Failed" is an application result; "safe to free" is a separate lifecycle fact. A recoverable appliance needs both graceful cancellation and conservative quarantine when proof is unavailable. [18][19][25][29]

### Making durability a checked result

CRC recovery detects torn records; durable callbacks make commits stable; consensus establishes replicated authority. None substitutes for another. Application revision changes, auth persistence and model-source mutation exclusion need to propagate the real commit/failure outcome rather than return success on an intermediate queue receipt. [17][20][26][32]

### Replacing infrastructure without inheriting its assurance

From-scratch TLS, authentication, SMB and storage implementations must interoperate with independent clients and survive malformed input. Known-answer crypto tests are more meaningful than self-round-trips; real SMB client mapping is more meaningful than a packet fixture. Current signing/identity and STS/cluster enforcement gaps prevent blanket security-readiness claims. This paper identifies acceptance boundaries, not a vulnerability audit. [7][14][29][32]

### Preserving one contract across multiple runtimes

C and browser PicoScript runtimes, generated assets, vendored crypto/replication copies and native/model adapters can drift. Exact upstream pins, local-delta records, numerical contracts and differential execution are essential. Blank licence fields and obsolete paths in the component manifest are release-engineering gaps, even when individual components build. [1][21][32]

### Scaling beyond narrow memory and storage budgets

The kernel raw image, process arenas, tokenizer memory, model workspace, DMA windows and GPU local memory are different budgets. Optional packed application images help fit the boot slot, but do not solve runtime reservations. Some feature builds have approached the Pi raw-slot limit closely. Recent high-memory probing is useful but not exhaustive stress or proof that all DMA can reach that RAM. [18][29]

### Selecting performance paths by workload, not label

Dispatch, data copies, synchronization, weight access and tiny workloads can erase GPU benefits. Fused batches and resident weights are the right direction, but must preserve the actual quantization and numerical contract. Generic INT4 support does not imply GGUF Q4_K compatibility; a supported header format does not imply a supported model architecture. [18][23][35]

**Measurement discipline:** PicoWeb's published Linux request-rate figures are not Pi 5 capsule measurements. The 19 November small HTTP-response baseline is not a bulk-transfer benchmark. Historical QPU profiles show workload-specific crossover, not general AI throughput. No current PicoSuite-wide latency, tokens/second, energy or cost claim is defensible from those measurements alone. [7][8][29][35]

## 7. Common features, searches, patterns and learnings

These focused searches were run against the follow-up baseline above. The examples below use `rg` from the repository root in PowerShell; they are starting points for inspection, not proof that all instances or all implementations have been found.

```text
rg -n 'generation|capacity|producer|consumer' components\pios\include\service_fifo.h
rg -n -g '*.{h,c,md}' 'sync|incomplete|CRC|recover' components\picosuite\picowal\portable
rg -ni 'backpressure|continuation|FIFO|AIRQ' components\pios\docs\network_stack.md
rg -n -g '*.pc' 'ValidateToken|Principal|auth_bound|need_auth' services\picologin services\picoai services\picosearch
rg -n 'RESP_END|Resp\.End' components\pios\src\picovm.c
rg -n 'renderSafe|createIndex|aria-selected|disclosure|skipNav' components\baremetaljstools\src\BareMetal.Markdown.js components\baremetaljstools\src\BareMetal.Search.js components\baremetaljstools\src\BareMetal.Tabs.js components\baremetaljstools\src\BareMetal.Controls.js components\baremetaljstools\src\BareMetal.A11y.js
rg -ni 'host_tests|qemu|build_bootstrap' .github\workflows\ci.yml
```

| Feature | Observed pattern and reusable learning | Boundary or exception |
|---|---|---|
| Ownership and IPC | FIFO descriptors carry owner, generation, length and capacity; producer and consumer indices occupy separately owned pages. Make authority, lifetime and publication rules explicit at the boundary. [9] | A descriptor contract does not prove that every bridge or cancellation path has converged on it. |
| Backpressure and progress | The documented network pipeline retains upstream work when downstream capacity is exhausted and records stall/resume diagnostics. Design for credit returning, not just the first successful enqueue. [7] | The cited host tests and documented path do not replace repeated physical acceptance or prove all legacy polling has disappeared. |
| Storage and recovery | Portable PicoWAL checks append records, exposes a `sync` durability boundary and marks exhausted derived indexes incomplete. Separate commit, recovery and query-completeness guarantees. [17] | The portable transaction unit is one put/delete; adapter correctness and physical persistence still need independent validation. |
| Identity and control flow | PicoLogin explicitly returns after a failed token check. PicoAI and PicoSearch call a `void` `need_auth()` and then continue to their handlers; the inspected C VM's `Resp.End` hook itself returns without terminating the handler. Check the actual failure path and its side effects, not merely the presence of a validation call. [15][22][36] | This is a source-level observation, not an end-to-end vulnerability test; other hosting paths may behave differently. Fail-closed route tests remain important. |
| Browser tooling | The toolkit exposes a safe Markdown renderer, an indexed search API, keyboard-aware tabs, disclosures and skip navigation. Compose small, accessible capabilities rather than assuming a framework is required. [37] | Accessibility, safe input handling and correct load order still depend on the consuming page. Client-side checks are not server authority. |
| Validation and release | Root CI explicitly runs kernel host tests and documents the missing Windows-hosted QEMU job. State exactly which stage each test covers and keep missing gates visible. [33] | Host-suite status cannot certify Pi builds, QEMU integration or physical-device behavior. |

These are engineering observations, not a comprehensive security review. They illustrate how the same bounded-ownership discipline appears in multiple layers, while also showing why a common-looking helper or a passing fixture is not sufficient evidence of end-to-end behavior.

## 8. How far through is PicoSuite?

One percentage would obscure the actual risk: components can be locally complete while a cross-layer ownership or identity seam is unfinished.

| Area | Evidence-based stage | What is still needed |
|---|---|---|
| BareMetalJsTools | Broad implemented browser toolkit | Reproducible vendored-tree validation, release packaging and actual app journeys |
| Portable PicoWAL/search/codec/parser libraries | Implemented bounded components with focused tests | Scope-specific interoperability, fuzzing, adapter durability and consuming-app integration |
| Linux PicoWeb | Implemented native server; historical deployment/performance reports | Current reproducible deployment evidence; distinguish optional protocol paths |
| Native PicoSTS | Implemented auth/store/route component | Complete deployment, persistence failure, grant/revocation and provider integration evidence |
| PIOS kernel | Operating hardware-backed development platform | Remaining async/lifecycle work, clean reproducible release gates and current hardware regression |
| PIOS identity/cluster services | Contracts, source and test slices | Production capability hosting, enrollment, mTLS, quorum storage and failover |
| PicoDesk | Implemented local developer/productivity desk | Production single-origin auth/storage/capsule migration |
| Target `apps` servers | Authentication/health boundary stubs | Actual app routes and data, permissions, transactions and deployment |
| Native model engine/service | Extensive port/provider/host integration; limited historical QEMU output | Repeatable clean CPU execution, concurrency, lifecycle and physical proof |
| Arc GPU model execution | Bounded physical tensor proof plus resident-model software wiring | Upload, full numerical/semantic inference, retirement, device-loss recovery |
| Integrated PicoSuite appliance | Integration and acceptance stage | All required vertical slices, operations and release gates |

Root CI currently runs the kernel host suite on Ubuntu. It does **not** supply root Pi/QEMU builds or QEMU smoke. The five latest returned workflow runs were failures dated 18 November; the inspected latest run failed at the host-test step. Those runs are not the reviewed HEAD, so they neither certify nor disprove this working tree. They do show that a current green, end-to-end automated release baseline cannot be assumed. [32][33]

The repository permits software completion and merges before batch hardware acceptance. Production release requires the full regression and outstanding hardware gates to pass. Hardware limits are therefore a validation queue, not permission to call an unverified feature complete. [1][29]

## 9. Path to go: an acceptance-driven roadmap

The sequence below is a research recommendation within existing architectural direction, not a new commitment, architecture decision or calendar estimate. Independent component work can continue in parallel; dependency-sensitive features should graduate only after the named seam works.

| Milestone | Deliverable | Exit evidence | Relevant current work |
|---|---|---|---|
| **A. Reproducible platform baseline** | Exact source/provenance/build map; current host gates; Pi/QEMU builds and genuine QEMU smoke | Clean snapshot builds, correct size/memory gates, real failing gates, preserved diagnostics | #43, #255, #256 |
| **B. Shared authority and service lifecycle** | Durable identity, scoped grants, verified caller context, canonical service handoffs and safe retirement | Negative grant/replay tests; revoke/exit/disconnect/full-queue tests; no unsafe reuse or success-before-sync | #178, #258, #194, #260, #192 |
| **C. One productive application slice** | Sign in once, open two distinct capsules, save/reopen data through real storage | Actual Sheet/Doc/List API operations; permission separation; checked durable save; restart recovery; shared service map | Existing app/package plan; #170, #168 |
| **D. Repeatable CPU model service** | One pinned checkpoint and tokenizer through the compiled capsule, FIFO broker and native provider | Independent exact output/intermediate comparison on a clean build; bounded cancellation, worker loss and overlapping requests | #45, #167, #172 |
| **E. Resident B50 inference** | Authenticated upload and a reusable resident model on one device generation | Full file/component verification; all-layer/head coverage; exact reference answer; correlated markers/guards; safe retirement and loss handling | #39, #191, #192, #195, #167, #41 |
| **F. DaveAI end-to-end integration** | Real application tier consumes the proven inference service without sharing its failure domain | Verified identity scope; real streamed output; cancellation/slow-client/restart journeys; measured queue/prefill/decode | #14 and inference API contract |
| **G. Cluster service graduation** | Explicit provisioning, enrollment, tenant discovery, three durable replicas and service routing | Fresh-node boot; mTLS; 2/3 durable commit; quorum-loss refusal; stale-writer fencing; replay and failover | #44, #178, cluster hardware gates |
| **H. Product and release expansion** | Remaining app APIs, selected native helpers and operational packaging | Real app acceptance, full regression, all required physical gates, reviewed licence/provenance and recovery documentation | App plan and hardware gate ledger |

For milestone E, the existing physical semantic target is deliberately concrete: the pinned Falcon checkpoint must answer **"The capital of France is Paris."** for the fixed chat-template prompt, with coverage for all 18 layers, seven projections and attention, plus all 1,366 output-head tiles per completed token on one B50 generation. Host mocks do not satisfy it. Start with a verified enumerated device and sufficient Transfer capacity, then use the build -> deploy -> live-verify loop. [18][29]

For milestone G, native Linux Raft/gossip source is valuable reference material, not proof of PIOS cluster implementation. The approved storage target requires one current-term writer, committed follower reads and three durable replicas with 2/3 majority. Gossip, DNS preference, VIP ownership or a local WAL write must never substitute for that authority. Authenticated replication records provide integrity/deduplication, not consensus by themselves. [10][12][34]

SMB must also graduate honestly: the current Transfer implementation advertises SMB2 2.0.2/2.1 with signing unsupported and a restricted development guest path while STS is unavailable. The target authenticated, signed SMB 3.1.1 cluster/file service is a separate future acceptance level, not the current share. Actual Windows/Linux client policy and file interoperability matter. [12][29]

After milestone C, wider applications can reuse the proven auth/storage seam. After D, DaveAI can exercise a truthful CPU backend while GPU work continues. Multi-GPU and heterogeneous serving should follow safe one-device retirement, not bypass it. This ordering maximizes useful integration while keeping the most dangerous resource-lifetime assumptions explicit.

## 10. Conclusion

PicoSuite's strongest idea is a coherent platform discipline: **small reusable components, bounded execution, explicit ownership, durable state and capability-oriented services from hardware to browser**.

The repository contains far more than a concept or collection of empty scaffolds. It also contains enough explicit gaps, failed experiments and partial proofs to make a blanket production claim inappropriate.

The next phase is primarily **graduation of seams**: from source to reproducible execution; from tested primitives to real services; from correct outputs to safe retirement; and from useful local tools to one authenticated, recoverable appliance. Completing those transitions will determine whether PicoSuite's architectural simplicity becomes operational simplicity.

---

## Evidence index

Links resolve to the local repository documents/source unless explicitly marked as GitHub. They describe the reviewed evidence snapshot; moving documents and issue bodies may change after this date.

| Ref | Repository evidence |
|---|---|
| [1] | [Platform overview](../README.md), [repository rules](../AGENTS.md), [component manifest](component-manifest.md) |
| [2] | [Application capsule status](../apps/README.md), [representative Sheet stub](../apps/sheet/server/sheet.pc), [application plan](../picoplan.md) |
| [3] | [PicoDesk overview](../components/picodesk/README.md), [PicoDesk ownership/instructions](../components/picodesk/AGENTS.md) |
| [4] | [PIOS active platform policy](../components/pios/docs/platforms.md), [kernel overview](../components/pios/README.md) |
| [5] | [PicoSuite libraries overview](../components/picosuite/README.md), [actual CMake assembly](../components/picosuite/CMakeLists.txt) |
| [6] | [Kernel system architecture](../components/pios/docs/architecture_system.md), [kernel execution contract](../components/pios/AGENTS.md) |
| [7] | [Kernel network implementation](../components/pios/docs/network_stack.md) |
| [8] | [PicoWeb implementation/route boundaries](../components/picosuite/picoweb/README.md) |
| [9] | [Service FIFO ABI and implementation](../components/pios/include/service_fifo.h) |
| [10] | [Linux PicoCluster](../components/picosuite/picocluster/README.md) |
| [11] | [Linux PicoPod](../components/picosuite/picopod/README.md), [PicoReplicate](../components/picosuite/picoreplicate/README.md) |
| [12] | [Approved service/cluster/identity architecture](../components/pios/docs/architecture_decision_log.md) |
| [13] | [Kernel boot/storage architecture](../components/pios/docs/boot_storage.md) |
| [14] | [Native PicoSTS](../components/picosts/README.md), [public API](../components/picosts/include/picosts.h), [route implementation](../components/picosts/src/picosts_routes.c), [tests](../components/picosts/tests/test_picosts.c) |
| [15] | [PIOS PicoLogin](../services/picologin/README.md) |
| [16] | [PicoWeb userspace protocol status](../components/picosuite/picoweb/userspace/DESIGN.md) |
| [17] | [Portable PicoWAL](../components/picosuite/picowal/portable/README.md), [engine contract](../components/picosuite/picowal/portable/picowal_engine.h), [engine tests](../components/picosuite/picowal/tests/test_portable_engine.c) |
| [18] | [Model-service execution and integration history](../components/pios/docs/issue_167_execution.md) |
| [19] | [Internal ModelFifo and production attachment boundary](../components/pios/docs/internal_model_fifos.md) |
| [20] | [PicoWAL appliance/pack model](../components/picosuite/picowal/README.md) |
| [21] | [PicoScript source-of-truth audit](picoscript-audit.md), [shipped PIOS runtime map](../components/pios/docs/picoscript/README.md) |
| [22] | [C VM contract](../components/pios/include/picovm.h), [C VM implementation](../components/pios/src/picovm.c), [host bindings](../components/pios/docs/picoscript/PIOS_HOST_BINDINGS.md), [device design boundary](../components/pios/docs/picoscript/PIOS_DEVICE_BINDINGS.md) |
| [23] | [Native DaveAI direction](../components/daveai/docs/BIGDAVEAI_NATIVE_ARCHITECTURE.md), [native model port progress](../components/daveai/ports/modelcli_pios/PORT_PLAN.md), [text inference integration](../components/daveai/docs/PIOS_TEXT_API.md) |
| [24] | [BareMetalJsTools](../components/baremetaljstools/README.md), [representative namespace/binding source](../components/baremetaljstools/src/BareMetal.Bind.js) |
| [25] | [DaveAI QEMU streamed-portal evidence and limitations](../components/daveai/ports/bigdaveai_pios/PHASE_TWO.md) |
| [26] | [Inference API v1](../components/daveai/docs/BIGDAVEAI_INFERENCE_API_CONTRACT.md) |
| [27] | [Application/inference separation](../components/daveai/docs/BIGDAVEAI_API_SEPARATION.md) |
| [28] | [PicoDrive planned CAS API and current stub boundary](../apps/drive/README.md) |
| [29] | [Physical acceptance ledger and dated execution observations](../hardwaretestsneeded.md) |
| [30] | [PicoCompress](../components/picosuite/picocompress/README.md), [PicoZstd](../components/picosuite/picozstd/README.md), [PicoParquet](../components/picosuite/picoparquet/README.md), [PicoCrypto](../components/picosuite/picocrypto/README.md) |
| [31] | [Lexical search](../components/picosuite/picosearch/README.md), [vector search](../components/picosuite/picosearch_vector/README.md), [domain primitives](../components/picosuite/picowal.retailprimitives/README.md), [PicoJSON](../components/picosuite/picojson/README.md), [PicoHTTP](../components/picosuite/picohttp/README.md), [PicoBlob source](../components/picosuite/picoblob/src/picoblob.c), [PicoLog](../components/picosuite/picolog/README.md), [PicoDNS](../components/picosuite/picodns/README.md), [PicoDHCP](../components/picosuite/picodhcp/README.md), [PicoPXE](../components/picosuite/picopxe/README.md) |
| [32] | Current GitHub issue status: [#43](https://github.com/WillEastbury/SmoofOS/issues/43), [#14](https://github.com/WillEastbury/SmoofOS/issues/14), [#45](https://github.com/WillEastbury/SmoofOS/issues/45), [#167](https://github.com/WillEastbury/SmoofOS/issues/167), [#191](https://github.com/WillEastbury/SmoofOS/issues/191), [#192](https://github.com/WillEastbury/SmoofOS/issues/192), [#194](https://github.com/WillEastbury/SmoofOS/issues/194), [#255](https://github.com/WillEastbury/SmoofOS/issues/255), [#256](https://github.com/WillEastbury/SmoofOS/issues/256), [#257](https://github.com/WillEastbury/SmoofOS/issues/257), [#258](https://github.com/WillEastbury/SmoofOS/issues/258), [#260](https://github.com/WillEastbury/SmoofOS/issues/260), [#261](https://github.com/WillEastbury/SmoofOS/issues/261); inspected 20 November 2026 |
| [33] | [Root CI definition](../.github/workflows/ci.yml), [latest inspected failed host-test run](https://github.com/WillEastbury/SmoofOS/actions/runs/44289271404) |
| [34] | [Linux control-plane consensus contract](../components/picosuite/picocluster/docs/control-replication.md), [cluster ownership boundaries](cluster-contracts.md) |
| [35] | [Tensor placement and current broker limits](../components/pios/docs/tensor_selection.md), [canonical descriptor header](../components/pios/include/tensor_broker.h), [native tensor/QPU documentation](../components/pios/docs/tensor.md), [model-format inventory limitations](../components/pios/docs/model_inventory.md) |
| [36] | [PicoWatch service source](../services/picowatch/picowatch.pc), [PicoAI service source](../services/picoai/picoai.pc), [PicoSearch service source](../services/picosearch/picosearch.pc) |
| [37] | [Markdown renderer](../components/baremetaljstools/src/BareMetal.Markdown.js), [search index](../components/baremetaljstools/src/BareMetal.Search.js), [tabs](../components/baremetaljstools/src/BareMetal.Tabs.js), [disclosures](../components/baremetaljstools/src/BareMetal.Controls.js), [accessibility helpers](../components/baremetaljstools/src/BareMetal.A11y.js) |
