Most fitness apps rent their intelligence from the cloud. We are wiring ours into the Grid itself.
XyberRun is adventure-cardio: real runs that feed competition, story, and progression on the Neon Grid — not another dashboard you forget. The mobile app is still shipping toward production; the marketing site and early-access roster are live now. Stay tuned for the Welcome to XyberRun transmission (what the product is) and a Builder introduction transmission (who is building it and why).
This piece is a Circuit Edition — tech-stack updates and how local A.I. performs in real life coding a real app we intend to put in runners' hands. Product ship notes land in Changelog and deeper operator write-ups in Field Notes. Circuit Editions stay on the metal: stack, agents, and build velocity.
On our brand-spankin' new @NVIDIAAI DGX Spark (thank you @Microcenter!) — our local compute host — XyberRun runs a full agent stack: a 35B-class reasoning model, an autonomous coding agent, durable memory, and cron-driven checklist execution. It is not a chatbot bolted onto a spreadsheet. It is infrastructure that helps us ship the mobile app, the API, and the Neon City story faster, with more discipline, and without burning budget on inference every time an agent opens a file.
This Circuit Edition is the tour. Professional where it matters. Fun because the future should sound like something you want to run toward.
Why local intelligence matters
XyberRun is adventure-cardio: real runs, real competition, real lore. That product surface is cloud-native — Clerk auth, Postgres on Neon, tRPC, Expo builds, Railway deploys. Runners should never wait on our lab hardware.
But building XyberRun is a different job. It is thousands of files, strict typing gates, phased cleanup plans, regression tests, and a constant stream of "did we break watch sync again?" questions. That work benefits from an agent that can chew checklists overnight, respect repository rules, and remember what it already tried.
Local A.I. gives us three things cloud-only agents struggle to match at our scale:
1. Economics at leaf volume — overnight checklist runs and verify loops without treating every file read as a metered line item. 2. Repo-native cadence — cron, plan markdown, MEMORY gates, and Hermes skills wired directly to the monorepo, not a detached chat session. 3. Operator control — we own the brain, the memory plane, and the kill switch. When ACR is mid-leaf, we do not restart the engine because a hosted dashboard pushed an update.
The Grid still wakes up in the cloud for runners. The circuit that powers our build velocity lives on metal we control.
Want the next Circuit Edition when it drops? Sign up for updates at xyberrun.io/sign-up.
The stack — layer by layer
Think of Spark as a small power plant on the edge of the Neon City. Four layers, one loop.
Inference engine. @Alibaba_Qwen (35B-class MoE) served through AEON vLLM from @SpaceTimeViking on unified GPU memory — our default "brain" for agent work. It is tuned for tool use and checklist execution, not casual chit-chat. Context windows fine tuned for XyberRun purposes. If you've got model or serving tips for agentic coding on Spark-class boxes, drop them in the replies — we're always listening.
Agent runtime. Hermes from @NousResearch drives the brain: terminal and file tools, skills, session search, and gated slash commands. The phased-checklist skill is the spine — agents code based on phases and leaves, plan markdown as single source of truth, compression when context fills, early handoff before turns run out.
Memory plane. @mem0ai writes pointers into @qdrant_engine; a local embedder handles vectors; MCP can call Postgres. The agent remembers where it was in a plan, not a second copy of the whole checklist. Human corrections flow into skill references via `/learn` so we do not re-discover the same mistake every sprint.
Grid ops. Systemd units for the gateway, Discord surface, and vLLM; `checklist-mem` for continue/stop gates; cron auto-resume every few minutes when status is CONTINUE. Circuit Editions and build chatter also surface on Discord — join the server at discord.gg/7TCBJkV6XB.
None of this replaces human judgment on product calls. It amplifies execution on the calls we have already written down.
What it unlocks today
Adversarial code review at scale. Our ACR plans are long on purpose. An agent that can hold the plan, run `npm run verify`, fix typing debt without workarounds, and mark leaves complete is the difference between "we should clean this up someday" and "lane 4.10 is actually done."
Overnight leaves. When MEMORY says CONTINUE and cron is enabled, Spark keeps working while the team sleeps. Morning review is diff-shaped, not archaeology-shaped.
Discord as an ops console. Hermes on your phone — gated commands, checklist progress when boxes move, and CI failures piped into chat. When a job goes red, point a purpose-built local agent at it and keep working from Discord instead of opening the terminal. Runners and builders are welcome in the same server — discord.gg/7TCBJkV6XB.
Continuity across leaves. Plan markdown stays SSOT; Mem0 and Qdrant hold pointers so each fresh Hermes session knows which leaf is active. Compression and `/learn` when context fills — the next agent picks up the thread without re-explaining the whole monorepo.
How it moves XyberRun forward
Here is the product translation — no jargon required.
Faster, safer mobile releases. Expo 57, TypeScript strictness, and navigation migration are not one-afternoon tasks. Agents that verify before they claim "done" shrink the gap between Preview and production.
Backend confidence. tRPC routers stay thin; services own orchestration; tests mock only at persistence boundaries. An agent trained on our AGENTS.md does not invent `publicProcedure` or silence the compiler with casts.
Feature lanes that ship. Product work — new screens, API surfaces, watch sync, social flows — still breaks into checklist leaves across backend and mobile. Spark keeps those lanes moving overnight so the next feature does not stall behind the last one.
Story without stalling engineering. Circuit Editions cover the stack; Changelog and Field Notes cover the product build. Local A.I. means we can afford to explain what we are building while we build it — without mixing those lanes.
We are not chasing AGI headlines. We are trying to make a small team punch like a disciplined studio. If that mission resonates, back the build on Support — Founders and early runners keep the Grid lit while we ship.
Guardrails we are keeping
Power on a bench needs rails.
- Plans are SSOT. Checkboxes and one "you are here" marker — not parallel todo systems or mystery handoff files.
- No mid-leaf engine restarts. vLLM image bumps wait until the agent is idle.
- Auth stays sacred. Login, OAuth, and session bridges do not get "helpful" drive-by refactors from unrelated leaves.
- Cloud for runners, metal for builders. Production data and user auth never depend on Spark being awake.
Sync the signal
The Spark Circuit is online. It will get smarter as we tune context, refine leaf handoff and overnight cadence, and teach the grid more of XyberRun's invariants.
If you run — XyberRun is adventure-cardio on the Neon Grid. This stack is why the app you will lace up in should feel fast, honest, and unfinished in the right places. Claim early access and get transmissions when we ship: xyberrun.io/sign-up. Start with Welcome to XyberRun, and stay tuned for the Builder introduction transmission.
If you build — Circuit Editions are the tech lane: local A.I. on a real monorepo, headed toward production. Join the Discord server for the community and live signal: discord.gg/7TCBJkV6XB. Follow Changelog and Field Notes for the product build itself.
If you want to fuel the next mile — Support is how a small team keeps metal and cloud both humming: xyberrun.io/support.
The runners get the Neon City. We get the engine room. Sync in — the Grid is brighter with every signal.