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.
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.
╔══════════════════════════════════════════════════════════════════╗
║ [ 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 →
WawaWasm Architecture for Walled ApplicationsWAWA 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 basement — bubblewrap 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 journal — hammerd 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 batchedtrait 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.
→Semantic engine injection — local RAG and autonomous agents implemented without corporate data leakage.
→Critical internal tooling — high-performance GPU clients and local P2P nodes for operations where latency or the cloud are not an option.
sergio@gioser:~$
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.