Navigation
Overview Architecture Research & SDK About Access Portal
Download SDK (v0.1)
AI Cell Fabric & CellOS kernel

Decentralizing neural states into autonomous micro-compute cells.

Celos Labs builds event-driven spatial computational substrates designed to replace legacy centralized GPU architectures with zero-bus-bottleneck in-memory execution cells.

Measured, v0.1
4.2%
of cells active per routed event, 16×16 fabric

01 // The Mission & Milestone

Core execution paradigm

Redefining Hardware Topology

Traditional AI accelerators rely on monolithic memory bus shuffles that introduce compounding latency spikes. Celos replaces this with localized state containers that communicate entirely through peer-to-peer event messaging.

"Initial execution focuses on sub-millisecond event-driven reflex logic for edge vision systems, providing a lightweight software testbed before silicon tape-out."

CellOS
C₁
C₂
C₃
C₄

02 // Run It Locally

bash — quickstart
v0.1 Release
# CellOS Virtual Mesh Engine (v0.1) — source, not yet on PyPI
$ unzip cellos-emulator-v0.1.zip && cd cellos-emulator
# Initialize an 8x8 spatial cell fabric
python3 -c "import cellos; fabric = cellos.Fabric(dim=(8,8)); fabric.pulse()"
At a glance (measured)
Active cells per event 4.2% (16×16 grid)
Contention @ 128 concurrent 9.84× faster
System survival after 1 fault 93.6% vs 61.4%
The architecture

Eliminating the central memory bus bottleneck.

The core formulation defines each node as an autonomous operational unit: AI Cell = Compute + Memory + State + Routing.

Download the whitepaper (PDF)

Spatial Mesh Routing (4×4)

Packet headers navigate the fabric via explicit (X, Y) coordinate addressing rather than a shared bus.

0,0 1,0 2,2 1,2 2,3

Highlighted path: event packet routed 0,0 → 1,0 → 1,2 → 2,2 → 2,3 via peer-to-peer hops only.

Measured Results — CellOS v0.1

Real output from the reference emulator (Fabric vs. a shared-bus baseline, same machine, same code).

Software simulation, not silicon

For a single, isolated event, a shared bus is faster than the mesh in every grid size we tested — a fixed 2-hop dispatch beats a variable-length mesh path. The mesh's advantage only appears under concurrent load, where a shared bus must serialize every event through one resource:

Concurrent events Fabric (ticks) Shared bus (ticks) Bus / Fabric ratio
1 10.3 2.0 0.19× (bus wins)
16 21.8 32.0 1.47×
64 25.2 128.0 5.09×
128 26.0 256.0 9.84×

There is a crossover around 8–16 simultaneous events on a 16×16 grid, beyond which the mesh wins and the gap widens quickly — the regime relevant to edge-vision reflex workloads, where many sensor regions can fire near-simultaneously. Full methodology, caveats, and reproducible code are in the whitepaper.

Target Runtime Specification

System requirements for the reference kernel and emulator implementation.

Target Architectures x86_64, ARM64 (Apple Silicon / NVIDIA Jetson) — anywhere Python 3 runs
Core Languages Python (v0.1 reference implementation, no dependencies); Rust kernel planned (Phase 4)
Measured Memory (v0.1) ~143.5 KB per 16 × 16 fabric, measured via tracemalloc on the Python reference build
Research & SDK

Active software emulation & developer toolchains.

Deploy local spatial cell matrices instantly with the CellOS Virtual Mesh Engine. Test event routing topologies directly in your native development environment.

bash — cellos-quickstart.sh
v0.1 Release
# CellOS Virtual Mesh Engine (v0.1) — source, not yet on PyPI
$ unzip cellos-emulator-v0.1.zip && cd cellos-emulator
# Initialize an 8x8 spatial cell fabric
python3 -c "import cellos; fabric = cellos.Fabric(dim=(8,8)); fabric.pulse()"
Download cellos-emulator v0.1 (source + benchmarks, .zip)

System Requirements & Emulator Target

Target environmental specifications for running local emulator instances.

Target Hardware x86_64, ARM64 (Apple Silicon / NVIDIA Jetson) — anywhere Python 3 runs
v0.1 Runtime Python ≥ 3.9, standard library only — no dependencies
Concurrency Model (v0.1) Single-process structural simulation — see whitepaper Appendix A
Future Roadmap Rust kernel + multi-threaded event queue (Phase 4, not yet built)

Cite This Work

Formal citation for academic and technical reference.

@techreport{simeon2026aicell,
  title={The AI Cell Model: Decentralized Compute and Modular Fault
         Containment as an Alternative to Monolithic Shared-Parameter
         Architectures},
  author={Simeon, Daysun},
  institution={Celos Labs},
  type={Working paper},
  year={2026}
}
Download the paper (PDF)
Founder & execution

One founder. One research direction. Built from first principles.

Celos Labs is currently founder-led, with the architecture, research direction, and CellOS development driven by Daysun Simeon.

DS
Founder

Daysun Simeon

Founder and systems researcher behind Celos Labs, focused on decentralized neural fabrics, CellOS, spatial execution, and the path from software research toward hardware realization.

LinkedIn

Execution Roadmap

Phase 1

Research & Whitepaper

Complete
Phase 2

cellos-emulator v0.1 (Python reference implementation)

Complete
Phase 3

Provisional Patent Filing

Planned
Phase 4

FPGA Emulation & Edge Vision Reflex Benchmarks

Planned
Phase 5

Custom Silicon Tape-Out

Planned
Engineering access & collaboration

Request access to the CellOS runtime & developer kit.

We onboard early-access research teams, edge computing developers, and deep-tech strategic partners on a rolling basis.

Secure TLS Encrypted Transmission