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.

A sample of the systems standing. These are not prototypes: they are pieces that compile, that run on real machines and that anyone can read line by line.

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. An organization's most critical infrastructure deserves this level of guarantee, not a backup script and crossed fingers.

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 — with the fluidity of a video game and the precision of a printing press.

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 update on their own. AI is one more thread, not the conductor. Built for publishers, legal teams and living archives.

An operating system anyone can run — even without opening a terminal.

A Linux distribution that understands artificial intelligence — and lets artificial intelligence understand you. Ask it in natural language for what you need: install a program, configure a server, recompile the kernel. The AI operates; the system guarantees that every change is 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.

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. Designed for communities and organizations that need to operate outside the umbrella of the big platforms.

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.

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

Cargo monorepo of ~210 crates with a strict four-part topology (00_unanchay / 01_yachay / 02_ruway / 03_ukupacha). Data flow is unidirectional; state is ephemeral; the persistent substance is the signed DAG in akasha. One domain = one root crate with plugin subcrates (*-core / *-app / *-cli / *-server); UIs are interchangeable frontends over the logic.

  • Llimphi — native interface rendering engine. Direct pipeline onto the GPU: wgpu (multi-backend HAL Vulkan/Metal/DX12), vello (vector rasterization via compute shaders + tessellated parametric curves), parley (shaping + Unicode BIDI + CJK/emoji fallback via fontique), taffy (flexbox/grid layout without a DOM). Deterministic Elm loop input → update → view → layout → raster → present; fully pure frames — the previous state is input, the next one is output. readme →
  • Mirada — native Wayland compositor in Rust. Implements the core subset of wayland-protocols + xdg-shell + linux-dmabuf + wlr-output-management; surface, focus and input management via libinput with no shim. Zero C or X11 dependencies — the graphics space is auditable code end to end. readme →
  • Wawa Wasm Architecture for Walled Applications WAWA is the Acronym for Wasm Architecture — bare-metal SASOS kernel (Single Address Space OS). A complete userspace composed of WASM modules with the runtime embedded in the kernel; security via typed capabilities (not POSIX uid/gid), isolation per WASM instance (not per process). Target x86_64-unknown-none, panic=abort, no_std; inter-module communication via akasha (signed DAG, postcard) without classic syscalls. readme →
  • Cosmos — astronomical observation engine with NASA-grade ephemerides. Loads JPL ephemeris (SPK / DE440) and VSOP87 series; Chebyshev interpolation over planetary positions in ICRS-J2000; transits, eclipses and aspects computed to sub-arcsecond precision. Solver decoupled from the visualizer — the math is auditable and portable to any frontend. 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. For when fidelity matters more than frame rate. readme →
  • Agora · Minga — agora: self-sovereign Ed25519 identity; signed capability tokens, transferable, revocable by revocation epoch. minga: distributed VFS over a gossip protocol; BLAKE3 content-addressing; per-file CRDTs (Yjs-style); no coordination server. Identity orthogonal to location — the same agent lives on any node. agora → minga →
  • Chasqui · Takiy — chasqui: typed broker with causal ordering via vector clocks; statically typed channels, at-most-once with hash dedup, no runtime coercions. takiy: composition and synthesis over the same model (MIDI 2.0 events + DSP graphs). The runtime that orders ACKs orders notes. chasqui → takiy →
02 · os · mutable + infallible linux

hammer

Hash-Addressed Mutable Manifest Execution Runtime

Linux distribution with its full control surface exposed as a typed IPC bus on /run/agent.sock. 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.

  • Deterministic basementbubblewrap sandbox (Linux namespaces + seccomp) + cross-compilation with zig cc + static linking against musl. Every derivation is a pure function (source_commit, recipe, deps_by_hash) → artifact addressed by BLAKE3. Bit-exact builds, independently verifiable.
  • Mutable userland — classic FHS (/bin, /lib, /etc) hydrated by hardlinks from the immutable store; patchelf rewrites RPATH so binaries find their dependencies by hash. No overlay FS, no covert read-only layers — the real filesystem is real.
  • Mutation journalhammerd daemon with fanotify (no polling, no shim) emits MODIFY|CREATE|DELETE events 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.
  • Agent bus — typed IPC over /run/agent.sock. Protocol: imperative requests (build, hydrate, try, commit, discard, apply, export) + journal event stream. Recipes compile in the sandbox, anchor to the store by hash and hydrate into the userland via hardlinks + patchelf. The surface is client-agnostic — AI, human or CI pipeline speak the same protocol. readme →
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 (eBPF, fanotify, headless browsers) → embedding (BGE-M3 / Cohere / mock) → index (HNSW + BM25) → alignment (cosine, Hungarian) → render (Llimphi GPU). Every link is a trait + interchangeable implementation. AI stops being a remote service and becomes infrastructure of your own — auditable and portable.

  • Nous — semantic explorer. HNSW index over BGE-M3 embeddings (1024-d) run locally; optional reranking with a cross-encoder. Incremental indexing via fanotify watch — the index stays consistent with the FS without a full sweep. Hybrid retrieval (BM25 + dense) with reciprocal rank fusion. readme →
  • Akasha — knowledge-graph rendering on Llimphi. Force-directed layout simulated on the GPU (compute shaders), massive instancing for >100k nodes, dynamic per-viewport LOD. Semantic edges (not just adjacency) by embedding cosine — the graph is a drawing of meaning, not of syntactic topology. readme →
  • Iniy — async batched trait Provider for embeddings; interchangeable backends (local BGE, remote Cohere, deterministic mock for tests). Content-hash caching. Cross-corpora alignment by cosine with MutuoMejor / MejorParaCadaA policies and Hungarian optimal assignment (declared, queued). readme →
  • Pluma — an editor over bodies versioned as per-atom CRDTs. Transformations (translate / tone / summarize / rewrite) are pure functions over the mother body, materialized into child bodies with alignment CartaHebras. Automatic staleness detection by mother-atom hash. AI appears as an interchangeable Ejecutor (Anthropic / Gemini / DeepSeek / local Ollama) — not as the conductor. readme →
  • Pineal — real-time visualization surface for local telemetry. Capture via eBPF + perf events + ringbuf; no remote agents, no sidecars. Live rendering on Llimphi at 60+ fps with circular buffers of up to 1M events. The operator's third eye. readme →
  • Puriy — the browser as a perception agent. Headless engine with structured DOM extraction (tables, hierarchy, schema.org data, JSON-LD); produces fact graphs consumable by Nous and Akasha. The web processed, not consumed. readme →
  • Khipu — notes as graph nodes. Outliner with block addressing, bidirectional links, transclusion by reference. Native format (BLAKE3 + DAG + postcard); imports from Markdown / Org / Roam via bridges in shared/foreign-*. 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 ] Wayland (Mirada), parsers for living documents, local telemetry, ingress via bridges (shared/foreign-*), native BLAKE3 DAGs.
[ yachay / logic ] Deterministic DAGs, local BGE embeddings, LLM-agnostic engines (Anthropic / Gemini / DeepSeek / Ollama), symbolic algebra, simulators.
[ ruway / action ] wgpu, vello (vector rasterization), parley (shaping), taffy (layout), Elm loop (Llimphi), typed broker, audio synthesis.
[ ukupacha / root ] Rust no_std, Linux fanotify, sled + postcard, SASOS kernel, sovereign cryptography (Agora), p2p VFS (Minga), isolated PostgreSQL.

[ 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.