The core of my work is CoreLink — a multi-tenant, content-addressed cache and execution fabric, live on Cloudflare's network across five production environments — where identical work is never repeated and compute is a disposable cursor over a shared store. The bill follows the structure: flat concurrency instead of metered minutes, zero egress instead of transfer fees. Rust, from edge workers to the kernel.
Software re-does finished work, constantly: the same dependency compiled on a million machines, the same node_modules filling a million disks, CI re-testing code nobody touched. CoreLink is built on one bet — work is a pure function of its inputs, so give every piece of work a content address, do it once, share it. Watch it run below: the logs are real. No aspirational tense anywhere on this page.
$ clw snapshot --name demo-journey . # tree → content-addressed snapshot $ clw hydrate /tmp/fresh --name demo-journey $ clw -v run --input src -- cargo test # memoized: unchanged inputs never re-run▋
Every artifact is addressed by what it is (BLAKE3), not where it lives — so the global cache holds one copy of everything. A teammate's build becomes your instant hit; CI's compile lands warm on your laptop. Public packages go further: a shared cross-tenant mirror fetches each wheel or bottle from upstream once, ever, while cryptographic tenant isolation — model-checked in TLA+ — walls every org's private work off. Your tools already speak it (Bazel, Turborepo, sccache; npm, pip, brew, OCI), and the store is zero-egress R2: pulling from the cache is free, exactly where S3-backed caches bleed.
Runners boot cache-warm: inputs are already local when the job starts, and memoized steps replay instead of re-running. Each job gets a fresh, fail-closed microVM, destroyed afterwards; images are digest-pinned and refused unless verified; boxes carry per-lease scoped tokens, never master credentials; every result returns as an Ed25519-signed attestation binding the full outcome. The bill changes shape — flat per parallel runner, unlimited minutes; modeled ~60–70% under hosted per-minute CI at typical use, before memoization zeroes the repeats.
clw snapshots a directory into the store and hydrates it on any machine in seconds — only the chunks that machine is missing travel. Heavy checkouts stop duplicating themselves across every laptop and runner; commands are memoized, so unchanged inputs never re-run; compute becomes a disposable cursor you point at work. The journey above ran these exact commands — install it and run them yourself.
A git-compatible, LLM-native forge for agent fleets. Serves the real git wire protocol (push/clone) directly from content-addressed storage; a union-tested landing queue batches green branches and, on red, a bisect isolates the culprit in ≤⌈log₂ n⌉ probes — a bound the test suite proves. Refs are an append-only, hash-chained event log with compensating-event undo, so a force-push can't destroy history; the Ed25519 integrity spine is hardened through 13 adversarial security-review rounds.
An MCP tool-server fleet on Cloudflare Workers — 630 tools across 37 deployable workers on one frozen kernel: a 3-tier fail-closed auth chain, Durable-Object distributed rate limiting, one dispatch pipeline written once. An OpenAPI→MCP forge generated the AWS surface; the value is the handwritten composite tools — Datadog temporal root-cause correlation, Stripe multi-currency VAT reconciliation, Vercel deploy-failure triage proven on a real failed deploy. BYOK per request, zero stored secrets.
My personal developer portfolio: standalone open-source builds, put in public to be read and run — active works in progress, still under development. Clone them, run the benchmarks, read the ledgers.
A daemonless, imageless container runtime in Rust — a from-scratch exercise in content-addressed, memoized execution — public and reproducible: no daemon, no images, memoized runs. On public CI it cold-starts rootless containers in 30.8 ms (4× rootless podman at identical isolation), replays memoized re-builds ~2,000× faster than Docker redoing the work, and its Kubernetes CRI backend runs at 9.32× smaller resident footprint than containerd. Every number traces to the CI run that produced it, in the repo's benchmark ledger.
An end-to-end-sealed data rail and Kafka-wire-compatible broker whose storage never sees plaintext (#![forbid(unsafe_code)]): per-cofre X25519 key-wrap, offline-verifiable Merkle delivery receipts, exactly-once into Postgres (CI-gated against real Postgres 16), FASP-style congestion control. An author-commissioned adversarial audit, run outside my own harness, measured the real broker binary at 3.0 ms cold start and 3.3 MB idle RSS through a 50,000-message cycle with zero loss — and grepped the data directory clean of plaintext.
One discipline runs through everything I build: a claim is worth only its evidence. A number carries the hardware and method that produced it, or it's labeled a target — never stated as fact. Limitations are named up front, prior art is cited, and nothing ships as "done" until a test says so. It's slower, and it's the only way I'd want my name on infrastructure.
_public namespace — the token gates access, the bytes are shared, and private packages never enter it. Every new customer leaves the mirror more complete for the next one.execv: EOF means the workload is truly running, bytes mean a diagnosed failure — closing the false-"Running" window most runtimes just tolerate.I've spent the last two years at the front line of what's probably the fastest revolution any industry has been through — learning the limits of working with LLMs first-hand, and building the processes and methods that get production-grade software out of them.
Before infrastructure, I ran product and delivery: founding Product Owner then Project Manager of a B2B commodities marketplace across Latin America, and operations for a construction company in Melbourne. Trilingual — English, Portuguese, Spanish.
São Paulo, Brazil (UTC−3). Open to remote or on-site roles worldwide. gustavo@humangr.com