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.
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.
╔══════════════════════════════════════════════════════════════════╗
║ [ 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_std —
format, 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 →
WawaWasm Architecture for Walled ApplicationsWAWA 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 →
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 basement — bubblewrap 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 distribution — 769 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.
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.
→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.