gioser

critical systems architecture

I design and build the technical heart
of infrastructures that have to last.

I'm Sergio Velásquez Zeballos.
I build from the underlying mathematics all the way to production, with no magic dependencies and no patches in between.
Gioser is my operating matrix.

01 — capabilities

Three fronts. One pair of hands.

I

Domain architecture

I design the complete system: domain, data, interface, deployment. A single counterpart from the first sketch to the first real invoice. For problems that no longer fit in an off-the-shelf SaaS.

  • Products in production from day one
  • Integration with legacy systems, no surprises
  • Documentation your team can operate from the start
II

Integrated artificial intelligence

AI that understands your business, not flashy demos. I integrate language models, embeddings and agents into the operational flow, measuring cost, latency and quality like any other component.

  • Internal assistants that take the load off entire teams
  • Intelligent search over your own documents and data
  • Portable AI — no ties to a single vendor
III

Sovereign infrastructure

Reproducible, auditable platforms, deployable on your own cloud or servers. No magic dependencies. If tomorrow you have to migrate, you migrate.

  • Deployments that rebuild themselves after any failure
  • Full security and performance audits
  • Zero lock-in by design
04 — approach

Four laws of operation.

Model before code.

Diagnosis precedes implementation. Every architecture decision is a priorities decision in another language — and it gets made with the business at the table, not afterwards.

Verifiable deliveries.

Short cycles, concrete artifacts: a demo, a deployment, a load test. What gets delivered can be touched. No intangible roadmaps, no PowerPoint milestones.

Code sovereignty.

The system is delivered documented and operable. No lock-in. You are the absolute owner of your infrastructure from day one — binary, source, keys, manifests.

Deterministic budget.

Closed cost per phase. Zero open-ended time & materials. Zero drift. The estimate is a contract, not an aspiration.

02 — projects

What's already built.

These are not prototypes or mockups: they are pieces that compile, that run on real machines and that anyone can read line by line. Everything below lives in two open codebases — tawasuyu (822 Rust modules, ~733,000 lines) and hammer (the operating system and its catalogue of 769 programs). Every figure on this page can be checked against the code, today.

A mathematically invulnerable operating system.

Every component is born from its unique cryptographic fingerprint. If something gets corrupted, you notice instantly; if something breaks, it rolls back in one command. Programs don't ask for permissions: if a capability wasn't granted and signed, the door doesn't even exist in the system. An organization's most critical infrastructure deserves this level of guarantee, not a backup script and crossed fingers.

In-house kernel of ~20,000 lines · boots end to end · 20 applications isolated from one another · read the project

A Linux that rebuilds itself — and that you operate by talking to it.

A distribution that compiles every program from source, in isolation, and stores the result under its fingerprint. Compiling twice yields the same binary, byte for byte: if a third party rebuilds the same thing and it doesn't match, something was touched along the way. On top runs a channel through which an artificial intelligence understands the system, proposes changes and applies them — with a safety net: tried aside, confirmed by hand, and every change recorded and reversible in one command. The distance between someone who has never opened a terminal and someone who maintains their own operating system disappears.

769 programs compiled and sealed · the Rust compiler and the Linux 6.16.12 kernel rebuilt from scratch, with no third-party binaries · full KDE desktop hydrated · read the project

A sovereign graphics engine.

An in-house renderer that paints straight onto the GPU. It makes it possible to build interfaces the browser cannot sustain — complex editors, living canvases, high-volume visualizations, three-dimensional worlds — with the fluidity of a video game and the precision of a printing press. It is the foundation every application on this page is built on.

70 ready interface components · in-house 3D engine · first Android APK compiled from that same code, with nothing rewritten · read the project

An entire desktop, written from scratch.

The program that draws the windows, splits the screen and handles keyboard and mouse. It is not a theme on top of someone else's desktop: it is the desktop. Multiple monitors, sessions that resume, configurable shortcuts and whichever look the user prefers. Where others integrate, here we build — which is why there is no foreign layer to audit, update or charge for it.

Daily driver · it is what the rest of the suite is built on · read the project

A canvas where one text lives in several languages at once.

A single document coexists with its translations, tones and summaries; when the original changes, its derived versions mark themselves stale and regenerate with one button. AI is one more thread, not the conductor — and the provider can be swapped without touching the document. Built for publishers, legal teams and living archives.

Translate, summarize, shift tone, and compare two documents as if they were layers · read the project

An in-house browser, with no Chromium underneath.

A page engine written from scratch: it parses the HTML, applies the CSS and runs the JavaScript of real sites — the one in the image is this very project, seen through it. It matters when the web stops being something you look at and becomes something your organization processes: pulling data out of portals, automating paperwork, auditing what a site executes before letting it run.

In-house style and JavaScript engines · third-party scripts run in a cage the user authorizes · read the project

Administration and accounting, without a monthly rent.

Real double-entry accounting, an in-house spreadsheet with formulas, invoicing adapted per country through a rules file — not through a different build of the program. It runs on the company's own server: the books don't live in anyone's cloud, and the day you want to migrate, they come out in open formats.

Journal, ledger and balance sheets · Excel import and export with verified round-trip · read the project

A digital identity that depends on no one.

Your identity isn't kept by Google or Microsoft: it is kept by you — cryptographically proven, transferable between machines, valid on any network willing to recognize it. With it you sign concrete, revocable permissions — who may run what, and until when. Designed for communities and organizations that need to operate outside the umbrella of the big platforms.

Sovereign keys already issued and in use inside the operating system · read the project

A personal platform of applied intelligence.

A laboratory where language models, personal records and daily practices converse in real time. The public experiment of how an AI can accompany thought without replacing it. It also serves as the proving ground for what we offer clients.

Notes that sync between machines with no central server · read the project

i.

The substrate of the old questions.

The deep disciplines — clinical psychology, contemplation, fine neurophysiology — don't need more slogans. They need instruments. Recording apparatus, reproducible archives, falsifiable models. Building that foundation so the old questions can find their experimental counterpart, without dissolving into self-help or surrendering to reductionism.

ii.

Science with instruments of its own.

Hypotheses that don't depend on foreign licenses or on platforms that change their terms tomorrow. Sensors, simulators, scientific databases operated locally — sovereign, reproducible. If the experiment depends on the vendor, so does the conclusion — and nobody is going to audit the vendor.

iii.

The extraordinary, in ordinary hands.

Graphics renderers, verifiable operating systems, robust cryptography, natural speech synthesis. Frontier technology deployed where it's most needed, not where it bills best. A cooperative should be able to operate the same things a bank operates; a rural school, the same as a university lab.

iv.

Infrastructure at street level.

A farmer with his archive. A doctor with the clinical record that travels with her. An activist with his private network. A neighborhood council with its own cloud. Sovereignty not as a flag or a speech — as everyday infrastructure, small, walkable, that turns on when the lights come on.

v.

Codes that carry a world.

The words code is named with are not neutral. A variable called khipu organizes memory differently than one called record. Building from one's own categories — from the south, from the countryside, from the deep traditions — is an act of engineering as much as a political one. What passes through the repository decides what survives.

05 — first line

The diagnosis starts with your description.

Tell it with the precision you'd use with a technical peer — the critical problem you need solved, the infrastructure you want to stand up, the technology that keeps failing. If what you describe calls for deep engineering, we schedule a technical session.

email sergio@gioser.net résumé sergio.gioser.net
location Caracas · Venezuela · global remote
sergio@gioser:~$
 ╔══════════════════════════════════════════════════════════════════╗
 ║  [ LEVEL 1 ] : SOVEREIGN ARCHITECTURE LABORATORY                 ║
 ║  OPERATOR    : Sergio Velásquez Zeballos                         ║
 ║  STATUS      : Compiling. Reading system topology...             ║
 ╚══════════════════════════════════════════════════════════════════╝

You're in the substrate. If you cut through the commercial layer and you're reading this, you're probably trying to gauge the level of isolation and rigor I operate with. There are no magic frameworks here. Only memory control, pure mathematics and deterministic design.

[ active_domains ]

The infrastructure splits into three axes of research and real production.

01 · workspace · rust

tawasuyu

822 member crates · ~733,000 LOC Rust · 4 quadrants

Cargo monorepo with a strict four-part topology (00_unanchay perceive / 01_yachay know / 02_ruway act / 03_ukupacha root). Data flow is unidirectional; state is ephemeral; the persistent substance is the content-addressed DAG. One domain = one root crate with plugin subcrates (*-core / *-app / *-cli / *-server); UIs are interchangeable frontends over agnostic cores. cargo check --workspace green on main is the minimum smoke test, not an aspiration.
The kernel (03_ukupacha/wawa) is excluded from the workspace — incompatible profile (x86_64-unknown-none, panic=abort); five cores cross that border by path and must compile no_stdformat, akasha, mirada-layout, forth-emisor, pluma-notebook-core — verified against wasm32-unknown-unknown by scripts/check-shared-cores.sh.

  • Llimphi — native interface rendering engine. Direct pipeline onto the GPU: wgpu 27 (multi-backend HAL Vulkan/Metal/DX12/GL), vello 0.7 (vector rasterization via compute shaders), parley 0.6 (shaping + Unicode BIDI + CJK/emoji fallback via fontique), taffy 0.9 (flexbox/grid layout without a DOM). Deterministic Elm loop input → update → view → layout → raster → present; pure frames — the previous state is input, the next one is output. Catalogue verified against the code: 70 widgets + 11 modules (MANUAL.md), an in-house 3D engine (llimphi-3d: SVO ray-marching, lights, bloom, SSAA) and an Android backend over the same View<Msg>. readme →
  • Mirada — Wayland compositor and full desktop environment (41 crates), on smithay 0.7 with a DRM/KMS + libinput backend. Beyond core and xdg-shell it implements linux-dmabuf, wlr-layer-shell, wlr-screencopy, wlr-foreign-toplevel, wlr-gamma-control, wlr-output-power, xdg-output, xdg-activation, xdg-decoration, xdg-foreign, pointer-constraints, relative-pointer, text-input + virtual-keyboard, fractional-scale, viewporter, tearing-control, security-context, idle-inhibit, primary-selection, data-control and XWayland. Multi-monitor with hotplug, per-output scale and wallpaper; WASM plugins whose capabilities are derived from their imports, Ed25519-signed — fail-closed. readme →
  • Wawa Wasm Architecture for Walled Applications WAWA is the Acronym for Wasm Architecture — bare-metal SASOS kernel (Single Address Space OS), ~20,100 no_std lines, cooperative reactor (100 Hz PIT + IRQs). Userspace = WASM modules on wasmi embedded in the kernel; 20 apps compiled to wasm32-unknown-unknown. Security is not a permission table: if the capability bit isn't set, the function is never registered in the linker — a physical border. On top of that, capabilities keyed by bytecode hash (Ed25519-signed grants, verified zero-alloc in the kernel, fail-closed: a declared-but-invalid grant means zero permissions). Content-addressed BLAKE3 store with mark/sweep/swap GC; in-house network protocol (akasha) on its own EtherType, no TCP/IP. Boots end to end on QEMU/UEFI. readme →
  • Cosmos — pure-Rust ephemerides, no runtime FFI: VSOP2013 planetary theory (Mercury→Pluto) and ELP/MPP02 lunar theory (Chapront & Francou 2003) with coefficients embedded and ablated from the original dataset, plus an in-house JPL SPK kernel reader (DE440/DE432s) when sub-metre precision is wanted. Declared and measured error: ELP/MPP02 < 5 km vs JPL DE441 over ±50 years — sub-arcsecond for pointing. A validation harness compares against JPL Horizons and Swiss Ephemeris (cosmos-validation). The solver is decoupled from the visualizer: skywatch, sundial, tides, eclipses, rise-set and astrocartography are independent extracts. readme →
  • Dominium — simulation engine on pure event-sourcing. State at any instant is a deterministic function of (seed, ordered event sequence). A DAG of forks for parallel hypothesis exploration; snapshot/replay with structural identity; per-event seeded PRNG, no wall-clock. Today it is used as an agent-based modelling laboratory — series and observables over runs, not a toy. readme →
  • Agora · Minga — agora: self-sovereign Ed25519 identity (ed25519-dalek in userspace, ed25519-compact zero-alloc mirrored in the kernel) and capability grants signed against the artifact hash, revocable. The genesis ceremony has been run: a ring of three sovereign keys (seeds kept outside the repo) and the system's grants signed and seeded into the image. minga: distributed storage over sled, BLAKE3 content-addressing, per-file CRDTs, no coordination server. Identity orthogonal to location. agora → minga →
  • Chasqui · Takiy — chasqui is two things: Brahman, a deterministic type broker — modules declare typed input/output flows and the broker matches consumer↔producer by exact and structural matching, with priorities and per-context biases, without moving a byte — and Nouser, data intelligence: it scans directories into monads (semantic clusters) enriched by swappable embedding providers (deterministic mock 32d / real ONNX 384d), with local-first discovery, DHT fallback and remote consumption over libp2p. takiy: real-time synthesis and sequencing (measurable xruns) that is deterministic on demand — same seed, same WAV; its first real consumer is supay's audio engine. chasqui → takiy →
  • The application layer — no demos: applications in use. nahual (file manager with parity measured against Thunar and Dolphin; viewers dispatched by content), shuma (block terminal with a GPU grid, workspaces and tiling), nakui (double-entry ERP + in-house spreadsheet + per-country tax packs declared in Nickel), hampi (health records with a ↔ FHIR R4 bridge, seven resources with verified round-trip — the anti-lock-in policy), paloma (multi-account mail over OAuth2/PKCE + source-citing RAG), kamachiq (deterministic WASM soft-PLC with replay), churay (signed installer/updater), qillqa (tamper-evident public registry with offline-verifiable inclusion proofs), arje (in-house bootloader + PID 1: it runs as init on a real production server — SSH, Caddy, PostgreSQL and Gitea alive under it). Foreign formats enter through shared/foreign-* bridges — never into the core. nahual → nakui → hampi → arje →
02 · os · mutable + infallible linux

hammer

Hash-Addressed Mutable Manifest Execution Runtime 12 crates · ~27,400 LOC · 769 recipes · 765 sealed

A two-storey Linux distribution: a hermetic laboratory in the basement that builds everything from source at pinned commits, and a classic, mutable userland upstairs (real FHS: /bin, /lib, /etc). System state factors as the composition of a BLAKE3 content-addressable store and an append-only fanotify journal of userland mutations. Every state transition is expressed as a reproducible .swm recipe — source diff + compile flags + configuration edits — hash-verifiable by the receiver with no trust in the sender. The binary never travels; the derivation does. Rollback is semantically equivalent to re-anchoring the journal root. Nix is neither used nor imitated in the build: the CAS, the graph and the hydration are in-house (ADR 0004).

  • Deterministic basementbubblewrap sandbox with --unshare-all (net, pid, mount, ipc, uts, user: no network during the build, today), base and dependencies mounted read-only by overlay, only two real RW surfaces (/src, /out), pinned environment (SOURCE_DATE_EPOCH, CC, -mcpu=baseline, CARGO_BUILD_JOBS=1). Cross-compilation with zig cc and static linking against musl — no musl-gcc anywhere in the chain (ADR 0003). Every derivation is a pure function (source_commit, recipe, deps_by_hash) → artifact addressed by BLAKE3.
  • Boot sovereignty, verified — the Rust chain is raised with no prebuilt binary from anyone: mrustc → rustc 1.90.0 (bundled LLVM) → 1.91.0 → 1.91.1, self-consistent and bit-reproducible, checked inside a VM (scripts/selfhost-verify.sh, scripts/rust-frontier/). The kernel is in-house too: Linux 6.16.12 built by the linux.toml recipe with SECURITY_LANDLOCK + AUDIT explicitly declared, which boots the VM and reproduces identically. Build twice, get the same artifact — if a third party rebuilds and differs, something was touched.
  • harkaq — the cage that also proves (SDD 16; crates/hammer-build/src/harkaq.rs, wired into the real sandbox and exercised on three machines: laptop Landlock ABI 10, VPS farm ABI 7 and the in-house kernel). Inert by default — it turns on with HARKAQ=1 and without it not a single bwrap argument changes: switching on a diagnostic must not move the hash of 700+ already-sealed artifacts. Landlock + seccomp over the build sandbox, with three core decisions: policy = closure (what is allowed derives from the declared dependency graph, not a hand-written list), negative evidence (the Hermetic/Impure verdict comes from what the process attempted and was denied, with audit), and seccomp as a denylist (closes ptrace→EPERM without moving the artifact hash). The by-product is worth more than the product: the absence of denials is mechanical evidence that what was declared suffices.
  • Mutable userland — classic FHS hydrated by hardlinks from the immutable store; patchelf rewrites RPATH so binaries find their dependencies by hash (ADR 0005). No overlay FS, no covert read-only layers — the real filesystem is real: you can overwrite a file live, break things with rm -rf, and roll back.
  • Mutation journal — the hammerd daemon uses fanotify (no polling, no shim) and emits MODIFY|CREATE|DELETE indexed by inode into an append-only log. The log is not declarative: it is an ordered sequence. Rollback = re-anchoring the log root to a previous offset. The state's identity is the hash of the log up to that point. The journal is the configuration — without being declarative.
  • Agent bus — JSON-line IPC over /run/agent.sock (SDD 07). Mandatory handshake (hello/welcome) and minimum capabilities: by default an agent only gets query; compile, inject (to an overlay) and inject-real (to the real FHS) are granted separately, and inject-real requires human confirmation. Commands compile · inject · query · init; events build_ready · build_failed · crashed · modified. The self-repair loop is real and auditable: the AI breaks the web server, hammerd emits crashed, the AI reads the log, fixes the source, rebuilds and restarts — with every step left in the bus and in the journal.
  • Catalogue and distribution769 recipes, 765 sealed (docs/state/build-state.json, 2026-07-25): 226 Rust, 362 Go, 144 C, 31 GUI, 6 kernels; profiles closed by dependency closure (base 51, cli 74, escritorio-mirada 31). The KDE front stands at 962 nodes / 958 sealed, with the escritorio-kde profile closed: 162 closure nodes, 162 sealed. Complete .swm packaging: packing, signed index, install/uninstall, dependencies, HTTP repository and mirrors. TUI installer and EFI/ISO images.
  • The border with tawasuyu — not two loose worlds: they share a BLAKE3 CAS (b3:), an arje ↔ hammerd bus with a byte-level wire contract, the boot graph (ADR 0010) and arje as the images' own init (ADR 0007), static against musl. What remains open is written down and prioritized, not assumed: M-of-N rebuild consensus and why-differs (SDD 17). repository →
03 · local perception engines

cognitive substrate

A stack of engines that extract, index, align and visualize knowledge without a single byte leaving the machine: local capture (filesystem, mail, web) → embedding (local fastembed / remote / deterministic mock) → retrieval with source citation → explicit judgement of belief → rendering on the GPU. Every link is a trait + interchangeable implementation — and the mock is not decoration: it is what makes the tests deterministic. AI stops being a remote service and becomes infrastructure of your own — auditable and portable.

  • Rimay — the local language service. The verbo-daemon binary loads the model once and exposes it over a Unix socket; the client implements the same trait Provider as the in-process backend, so consumer code is identical whether the model runs inside or outside. Default real backend: fastembed / multilingual-e5-small (384d). One instance = one model; multi-model = N daemons. readme →
  • Iniy — semantic laboratory built on subjective logic: it models degrees of belief (belief / uncertainty / base rate, b·u·π) plus an explicit subjectivity direction axis (authorship, source, positionality) to audit claims in long texts. Pipeline ingest → extract → graph → NLI → report; sources carry reputation and support/contradiction relations are edges in the graph, not adjectives. Pilot: book and wiki audits. readme →
  • rag-motor — the agnostic abstraction of a RAG engine (shared/rag-motor). The rag widget is an interchangeable frontend, so two real corpora — mail (paloma-rag) and the event centre (willay-rag) — implement the same trait RagMotor and return answers with a numbered citation to the source. Read-only cache; no cited source, no answer.
  • Pluma — an editor over a sheaf of bodies: a document is a set of canvases (language, tone, audience, summary) over the same material, aligned paragraph by paragraph through CartaHebras, with atoms of stable identity. Transformations (translate / tone / summarize / rewrite / custom) derive a child body from the mother body; if the mother changes, the child goes stale and the UI draws the thread dotted until it is regenerated. AI appears as an interchangeable executor (Anthropic / Gemini / DeepSeek / Cohere / local Ollama, or mock with no credentials) — not as the conductor. Persistence on sled. readme →
  • Pineal — backend-agnostic visualization: a catalogue of specialized painters (cartesian, polar, mesh, treemap, heatmap, hexbin, contour, sankey, flow, financial, phosphor) that produce scenes on Llimphi and are certified by rendering headless to PNG — no window, no GPU required. The operator's third eye. readme →
  • Puriy — an in-house browser, with no Chromium and no WebKit. A real CSS cascade engine (specificity, inheritance, !important, var()/calc(), pseudo-elements, combinators, structural pseudo-classes, vendor-prefix aliases) with hundreds of properties plumbed into layout; JavaScript through QuickJS compiled to WASM and executed inside a sandbox. Beyond looking at the web, it processes it: structured DOM extraction to feed indexes and graphs, and a script-transparency layer that treats never-before-seen code as what it is — new code that must be authorized. readme →
  • Khipu — notes as nodes of a graph, with a canvas that orders by attention and P2P sync with no central server (relay / hole-punching / NAT detection over the in-house network layer). Native format (BLAKE3 + DAG + postcard); foreign formats enter through bridges, never into the core. readme →

[ laws_of_physics ]

.01

Topology as code. The repository's structure is the first design document. architecture ↦ filesystem is the primary map — if it takes an external PDF to understand it, the map is broken. Filesystem and architecture are not orthogonal: they are the same thing.

.02

Separation of responsibilities (S₀ → S₃). ∀ layer N: N depends only on N-1. The UI is blind, the logic is mute, the data is neutral, the root is inert. UI ⊥ logic ⊥ data ⊥ root. Unauthorized crossings violate the invariant and are rejected at compile time.

.03

Semantic sovereignty. The name organizes memory. The function f: symbol → structure is injective. Renaming to the generic destroys the mental map of the system. Renaming a domain is rewriting a domain.

.04

Reproducible determinism. ∀ x, ∀ M, M': P(x, M) ≡ P(x, M'). No hidden randomness, no unspecified floats, no unfrozen clocks. Once the property is proven, testing becomes a corollary.

.05

Monoidal composition. Domain = ⊕ᵢ Mᵢ with orthogonal modules Mᵢ, each carrying a single responsibility. Complexity scales by composition, not by inheritance. Deep hierarchy is a code smell; mandatory hierarchy is structural debt.

.06

Structural reversibility. ∀ mutation m over state s: ∃ m⁻¹ such that m⁻¹ ∘ m = id_s. Rollback is not a feature — it is a property. Systems without reversibility accumulate debt until they collapse; systems with it heal.

[ stack_by_quadrant ]

[ unanchay / perception ] In-house web engine (Puriy: CSS cascade + QuickJS on WASM), graph notes (Khipu), local embeddings over a socket (Rimay), multilingual canvases (Pluma), foreign formats entering through shared/foreign-* bridges (PSD, XLSX, DBF, EPUB, ODT, JXL, SVG, Lottie, FHIR, GeoTIFF, AV), native BLAKE3 DAGs.
[ yachay / logic ] Pure-Rust ephemerides (VSOP2013 / ELP-MPP02 / SPK), event-sourced simulation (Dominium), subjective logic (Iniy), molecular dynamics (Tinkuy), double-entry accounting and tax packs (Nakui), health records ↔ FHIR R4 (Hampi), LLM-agnostic engines (Anthropic / Gemini / DeepSeek / Cohere / Ollama / mock).
[ ruway / action ] wgpu 27, vello 0.7 (vector rasterization), parley 0.6 (shaping), taffy 0.9 (layout), Elm loop and 3D engine (Llimphi), Wayland compositor on smithay (Mirada), type broker (Chasqui), deterministic synthesis (Takiy), WASM soft-PLC (Kamachiq).
[ ukupacha / root ] Rust no_std, SASOS kernel with embedded wasmi (Wawa), in-house bootloader + PID 1 (Arje), fanotify, sled + postcard, Ed25519 identity and capability grants (Agora), distributed storage with no coordinator (Minga), unit control plane (Sandokan).

[ verification ]

None of the above asks for faith. Every claim in this layer is checked by running something.

[ the workspace compiles ] cargo check --workspace — minimum smoke test, always green on main. 822 member crates.
[ the cores are no_std ] scripts/check-shared-cores.sh — builds the five shared cores against wasm32-unknown-unknown. If a type travels over the in-house network or crosses into the kernel, its crate compiles without std.
[ the UIs exist ] scripts/shots.sh — every app ships an example that renders its interface headless to PNG (wgpu, falling back to software without a GPU). Screen debt is paid in images, not adjectives.
[ the kernel boots ] cargo +nightly run -p boot -Z bindeps — forges the UEFI image and boots it in QEMU, end to end.
[ hammer rebuilds itself ] scripts/selfhost-verify.sh — the Rust chain and the kernel are rebuilt inside a VM and compared bit for bit against the previous run.
[ the catalogue is sealed ] docs/state/build-state.json — state per recipe, class and profile, with the dependency graph closed and acyclic. 769 recipes, 765 sealed.

[ engagement_protocols ]

Conditions under which this architecture intervenes in external systems.

field · 0 / 5

What gives shape
to the world
has a geometry.

This is not a metaphor. It is an object of study. The vital force that organizes matter and thought leaves measurable traces: in affective tone, in somatic coherence, in patterns of attention, in what language keeps pointing at and cannot grasp.

This is not mysticism. It is the next layer of engineering: the one that admits the observer is also a system.

field · 1 / 5 · lineage

The plant. The lineage.
The sensitivity.

The cultures of the Americas have studied this technology for millennia. It is not a pharmacological compound to isolate, but an instrument of nature, transmitted by lineages that operate under strict protocols of rigor.

Its name — ayahuasca — precedes the word "psychedelic" by thousands of years. Speaking of it with discipline demands not reducing it to its pharmacological component, nor colonizing it with hasty neuroscientific vocabulary.

Its function, described in the most rigorous contemporary clinical terms: to purify the emotional intoxication accumulated in bodily memory and to open a sensitivity for penetrating the subtle form of reality. The knowledge surrounding it is not folklore — it is an epistemological tradition with its own criteria of validation, prior and parallel to modern science.

What this page describes was learned under that discipline. It is not for sale. It is respected.

field · 2 / 5 · coherence

Reality has the shape
of many mathematics
at once.

What that sensitivity gives access to is not linear. It is a multiplicity of self-coherent worlds — each sustained by its own internal grammar, like mathematics that hold themselves up without requiring external proof.

And above them, a metacoherence: the property that all those worlds are true at once without contradicting one another. Consciousness — that background so indefinable that it is no thing yet contains all of them — is what sustains the metacoherence. The serious practice is to summon the clarity needed to perceive how everything fits.

This is not rhetoric. It is a research program. Depth psychology, contemplative phenomenology and systems theory converge — read with discipline — on the same description. Janet, James, Bergson, Reich, Goodwin are the late Western proofs of something the American traditions described with clinical precision long before.

field · 3 / 5 · cycle

The cycle of information, in four seasons.

Unanchay

perceive

What comes in: sensation, sign, noise, data. The organ that does not yet judge. Here the system remains open.

Yachay

know

What gets ordered: model, map, hypothesis, narrative. The world becomes something one can think about.

Ruway

do

What gets projected: act, decision, work. Knowledge becomes gesture and touches the world again, changing it.

Ukupacha

root

What sustains the other three. The layer that is not seen and that decides the quality of everything happening above.

Walking all four completes the cycle. The practice is not to remain in any one of them. And in walking them, the observer rediscovers itself as the common substrate — the background where all four happen.

field · 4 / 5 · agora

From clarity,
consensus is the state
of minimum entropy.

Visible conflicts are collisions of partial coherences. From the clarity the practice grants, aligning energies to coordinate shared vectors and goals is not pacifist idealism; it is topological resolution and a technical consequence.

Technology — when used with discipline — can mathematically abstract the communication that coordination requires. A distributed agora, cryptographically sovereign, exempt from the particular domination of governments or borders. Where consensus is a provable property, not a fragile agreement or an external dictate.

That is what tawasuyu is oriented toward. The four directions — perceive, know, do, take root — are a journey, not a map. The destination is an agora-humanity: technical and semantic consensus among beings who recognize each other as peers, without passing through the mediation of a sovereign.

sergio@gioser.net

If you made it this far, it was not entirely an accident. Something brought you. That already puts us in the same language. Write without formality.