HECATE

A pluricellular organism of local AIs, built to grow when hardware arrives.

Below it: MESH_SILOS, AUTO_TARDEO and four private works, all local-first.

For teams that own their hardware and their data.

  • v3.4.0
  • MIT
  • Rust 1.88+
  • Python 3.10+

Explore HECATE All projects

Now

  • ADR 0026 accepted today: HECATE is a pluricellular organism, and the router is an organ of the tissue, not the product.
  • 1045 Rust and 558 Python tests green, and verification runs 18 gates on this machine with no cloud CI in between.
  • The emergent property is not measured yet: the benchmark the ADR names as its proof is not in the tree, so the ontology stays in observation.

Flagship

Pluricellular runtime · MIT · v3.4.0

HECATE

Several local AIs that behave as one organism: cells that serve on their own, a tissue that coordinates them, and a growth rule that changes the shape when hardware arrives.

Rust and Tokio in the tissue, Python and PyTorch in the data plane, one Protobuf contract. The scheduler builds topologies instead of choosing between models, and nodes hand over adapters, not data.

Explore HECATE Download

Twelve cells, six outer and six inner, joined into one tissue.
  • Rust 1045 tests
  • Python 558 tests
  • Gates 18 verification steps
  • Shape 10 crates · 26 ADRs · 130 documents
The tissue, running · 5.6 s loop · silent

Approach

Six projects, one shared constraint: each runs where the data already lives. The hardware is the deployment target, so there is no round trip to someone else's server and no per-token billing.

Where a number appears on this page it comes from a run a reader can repeat. Where the code is private, the card says so, and it ends up shorter than the ones that can show their work.

Releases are tarballs cut at the last commit: tests, notes and source, unpacked on a machine with no account on it.

Projects

Six projects in three tiers: the flagship above, two systems that ship, and four works that are private and say so on the card.

Illustration: two columns of stacked blocks facing each other, joined by thin crosswalk lines.

Supporting · data governance

MESH_SILOS

Map reporting silos into one crosswalk. No data moved, no network.

  • Python
  • FastAPI
  • DuckDB
  • Pydantic
Details
  • Version 0.8.68
  • EUPL-1.2
  • Python 3.11+
  • 188 test files
Illustration: a route drawn as a thin line crossing a dark field with its middle segment missing.

Supporting · social planning

AUTO_TARDEO

A night out that plans itself: the route stays hidden until the alarm, the bill is split by rule.

  • Cloudflare Workers
  • Hono
  • TypeScript
  • D1
Details
Illustration: a grid of pale dots on a dark plane, five of them ringed in lime.

Private · edge analytics

POC_RETAIL_ANALYTICS

Edge retail analytics: nodes re-identify people locally and share embeddings, not images.

  • Python
  • YOLOv8
  • ONNX
  • Radxa · ARM64
  • mTLS
Details
  • Licence not published
  • Hibernated 2026-10-11
  • Runs on a Radxa Cubie A7Z
Illustration: dense cyan and violet line work rising and falling on black, one branch breaking away.

Private · algorithmic trading

VIRAL_MFT

A colony of trading strains competing for capital, mutating when they underperform and pruned when they fail.

  • Python
  • C++20
  • CMake
  • FIX 4.4
Details
  • Version V1.0.0
  • Licence not published
  • Last commit 2026-10-11
Illustration: five translucent pages stacked in perspective on black, with a lime green horizontal line cutting through them.

Live · Reading

NEURAL BRICKS

RSVP speed reader: one word at a time, at the character the eye rests on, with AI summaries. Live at neuralbricks.org.

  • Vite
  • React
  • Tailwind
  • PWA
Details
  • Live at neuralbricks.org
  • Summaries via a Cloudflare Worker
  • English and Spanish
  • Source on request
Illustration: a single-board computer drawn as a flat rectangle with a grid of solder points and three traces leading out.

Private · port

RADXA_PICO_CLAW

PicoClaw, Sipeed's ultra-light Go AI agent, ported to Radxa single-board computers.

  • Go
  • Radxa SBC
  • ARM64
Details
  • Upstream PicoClaw (Sipeed), MIT
  • Go
  • Target Radxa SBC, ARM64
  • Status not published

Writing

The flagship is documented before it is described: fifteen technical notes, a verification method and a benchmark methodology, each readable as a page and fetchable as plain text.

About

Pablo Bolado Santamaría

I am a senior business analyst. My work sits in the seam between finance, the business and data engineering, and has done for years across asset management, banking, aviation and real estate: regulated industries where a number that cannot be traced is a number nobody will use.

Most of the job is the unglamorous half. Requirements that survive contact with the people who have to use them. A functional specification that actually ships. The dashboard that gets used instead of the one that wins the design review. An operating model that still holds a year later, when the analyst who wrote it has moved on.

I use Databricks, AWS, BigQuery, Power BI, SQL and Python myself, because a specification nobody can build is a wish with a deadline. Fluent English, native Spanish, intermediate Portuguese.

All of it is local-first for the same reason the day job keeps coming back to: the data belongs to whoever owns the hardware. That is why MESH_SILOS refuses to open a socket, why AUTO_TARDEO splits a bill with a rule instead of a conversation, and why HECATE hands over adapters rather than the data they were trained on. When a measurement contradicts the story, the measurement stays and the story is rewritten. That is what happened to this project's own identity.