Jonah Tarashansky / selected work / 2026

Built in the clinic.
Taken far beyond it.

I’m a veterinarian who learned to code to solve a problem I lived every day. I built the clinical platform, then a whole AI development swarm I can manage from my phone. The work now spans open-source AI tools, a mobile-friendly command-line app for controlling remote computers, and an interactive fractal explorer.

Clinical foundation
UC Davis DVM · 2019
First line of code
December 2025
My role
Sole founder & engineer

02 Agentic development

My development platform

Voxxo Swarm

The model is interchangeable. The accumulated work is the agent.

Each agent is a durable identity made from its transcript, task state, codebase knowledge and cognition, not a disposable model process. I can move a running agent to a different model mid-task while preserving its identity and working state, or fork inherited-context clones and whole squads so parallel workers begin already briefed.

Context Warp Drive carries decisions, evidence and open commitments through context limits and restarts. Durable task rails keep execution explicit. Atlas gives every agent source history, dependency maps and exact snapshots; Forge lets them turn repeated work into tested tools they can reuse.

Shared cognition cards, chatrooms, file claims, collision detection and independent review rings make the fleet coordinate rather than merely run in parallel. Live usage, cost and context telemetry keeps the system observable across providers.

It runs at fleet scale: nearly 3,000 agents have worked in Swarm since late August, with up to 199 in a single day and 99 running at once on one machine. It’s built to run lean. Each agent works inside its own memory limit, and heavy builds and tests are admitted only when memory allows. Those safeguards date from when Swarm ran on a 12-core, 24 GB server.

From the dedicated Mission Control mobile app on my phone, I can switch projects, inspect agent panes, speak or type instructions, fork workers, change models and intervene in live work. The same agents can navigate real browsers and, under supervision, operate a remote computer through a secure SSH bridge.

This is the system I use to build Voxxo. Its strongest ideas flow back into the clinic: Forge-built reusable workflows, long-horizon memory and learning loops that retain each veterinarian’s documentation preferences.

Explore the tools I’ve released

The agent stack

A whole swarm in my pocketProjects · Agent panes · Voice · Models · Progress
The model can change. The identity remains.
IdentityTranscript · Knowledge · Cognition
CoordinationForks · Rails · Claims · Review
ExecutionAtlas · Forge · Browsers · Tools
Many models. Shared institutional memory.One fleet

03 Long-horizon memory

Open source · MIT

Context Warp Drive

Agents that work for weeks without forgetting, and without paying full price to reread their own history.

Every AI agent works inside a fixed context window. When it fills, the usual fixes break something. Truncation throws away the work in progress. Asking a model to summarize itself costs another model call, loses exact details and rewrites the history the provider had already cached, so the next turn pays full price again.

Context Warp Drive is the engine I built instead. It folds history deterministically: no model calls, only CPU, and the same history always produces the same bytes. That one property lets an agent’s memory be long-lived and cheap at the same time. Providers bill cached input at a fraction of the normal rate, but only when the start of the prompt is byte-for-byte identical, and a deterministic fold keeps it identical turn after turn.

Most agents haul the whole haystack around to keep the needles. Context Warp Drive keeps the needles (file paths, IDs, the newest steps and the agent’s own reasoning) and leaves the hay in the barn. When a piece of hay matters again, it pages back in.

Swarm’s long-running agents run on it. I extracted it into a standalone MIT library that works with Anthropic, OpenAI-style and Gemini message formats, includes fold packs for Claude Code, Codex CLI and Gemini CLI, and ships with more than 900 deterministic tests. Brain MCP brings its rebirth to the Claude Code CLI.

How it works

  1. 01FoldOlder steps shrink to one line per tool call, plus the agent’s reasoning within a budget, while the newest steps stay word for word. A single task with hundreds of tool calls folds step by step, so it never outgrows the window.
  2. 02ConserveExact identifiers such as file paths, commit hashes, IDs and ports are carried forward verbatim, so folded memory still points at the right thing.
  3. 03FreezeThe folded history is sealed and reused byte for byte while new turns append behind it. That stable prefix is what keeps the provider cache hitting.
  4. 04RecallNothing is thrown away. The raw history stays on disk, and when the agent touches a file again, the evidence it folded away pages back in.
  5. 05RebirthAt the ceiling, measured from the provider’s own token counts, the conversation becomes one deterministic continuity package: the open request, edits in progress, task state, file claims and the agent’s own notes. The agent wakes in a fresh context as the same identity, still on task, even on a different model.

The cache numbers below weren’t earned by letting context pile up. Agents compacted it over and over, deterministically, so the cache kept hitting while each agent worked in a small context without losing stride.

92%
of 46.2 billion input tokens served from provider caches across 1,429 Swarm agents, September 15 to October 14, 2026
95.8%
of the 14.6 billion sent to Claude models, served from cache
90.3%
of the 31.6 billion sent to every other model combined, served from cache
87.5%
of interrupted tasks finished after a rebirth at the paper’s strictest machine-checked cut (780 of 891), and 91.3% when the interrupted request was mine
684
consecutive rebirths in the deepest measured chain, with no decline in success as chains grew deeper
1 turn
median cost of resuming an interrupted task, with two orientation tool calls

Cache figures are the token counts providers reported back, added up from Swarm’s usage ledgers rather than estimated: 42,562,290,016 of 46,245,952,638 input tokens came from cache (92.03%). Of the rest, 3.06 billion weren’t in the cache and 0.62 billion were written to it for later turns. The date window is fixed, so rerunning the measurement gives the same counts. Rebirth figures come from the rebirth-continuity paper: 22,444 turns and 8,717 rebirths across eight model engines. In its controlled test across five model families, rebirth matched a full-context summary at choosing the right next action. Benchmark method and data.

Open tools & experiments

Explore the source.

The systems behind my workflow also stand on their own. These public repositories show the engineering directly.

Open source · MIT

Atlas MCP

Give agents a map of the codebase.

Local code intelligence with structural search, dependency graphs, snapshots and a place to record the reasoning behind a change. A reusable MCP server, CLI and programmatic API.

Code intelligence / SQLite / MCP

View Atlas MCP on GitHub

Open source · MIT

Context Warp Drive

Long-horizon memory that keeps the cache hot.

Deterministic context folding with byte-stable prompt prefixes, recall and rebirth. The engine behind Swarm’s long-running agents, released as a standalone library with fold packs for Claude Code, Codex CLI and Gemini CLI.

Agent memory / Prompt caching / Rebirth

View Context Warp Drive on GitHub

Open source · MIT

Brain MCP

Swarm’s memory, inside Claude Code.

Atlas code intelligence, Swarm’s transcript search (Tap) and rebirth, packaged as one 23-tool MCP server for the Claude Code CLI. Install it, run brain setup, and Claude Code can search its own past sessions, query and record codebase history, and hand unfinished work to a fresh session that wakes up already briefed. It all runs locally on SQLite and an on-device embedding model, so you get these capabilities without adopting the full Swarm.

Atlas / Transcript search / Rebirth / MCP

View Brain MCP on GitHub

Public code

Swarm Chess

A benchmark arena where models play each other.

I pulled it out of my Swarm harness, where it pits models against each other: each color gets its own provider and model, round robins balance colors, and an Elo leaderboard ranks the field. The harness also tests whether a model plays better stateless, in one long conversation or across rebirth handoffs, and it guards against either side seeing the other’s reasoning. The public engine gives the model the board every turn, checks each move and returns illegal ones with the legal list for up to three retries.

Model benchmarking / Elo / State injection

View Swarm Chess on GitHub

04 Developer tools

Voxxo Term

A mobile-first terminal: SolidJS on top, Rust underneath.

Voxxo Term lets me connect to remote computers and run commands from my phone or browser. The interface is a SolidJS app. Underneath it, a terminal engine written in Rust and compiled to WebAssembly parses the terminal stream and draws it to a canvas. The Android app adds a native SSH client, and the controls are designed for touch as well as a keyboard.

  • SolidJS front end built with Vite, with touch-first controls and full keyboard handling.
  • Rust terminal core compiled to WebAssembly, with its own canvas renderer.
  • Native Android SSH sessions and key handling through a Kotlin client (sshj).
  • A Rust WebSocket-to-SSH relay reachable only inside my private Tailscale network.

05 Interactive exploration

Zooming Fractal

Follow your curiosity. Keep zooming.

An interactive Mandelbrot explorer for the browser and the phone. Pinch to zoom, then keep going far past the roughly 1015 magnification where ordinary 64-bit math gives out. The camera tracks its position in arbitrary-precision BigInt arithmetic whose precision grows with depth. Past 2100 the renderer switches to scaled perturbation theory: a high-precision reference orbit is computed off the main thread, the GPU renders every pixel as a small offset from it, and a guard catches the glitches that appear at extreme depth.

  • WebGL2 rendering with Three.js and custom GLSL shaders.
  • Touch pan and pinch zoom on phones, installable as an app, plus an Android build.
  • Julia sets, formula variants and orbit traps.
  • Shareable locations, image export and recorded zoom journeys, including audio-reactive video.
Open the live explorer
The Mandelbrot set rendered in Zooming Fractal, surrounded by peach, yellow and violet detail.
Actual browser capture · October 2026

Opens directly in the browser. No account needed.

The thread through it all

Build it. Use it.
Make it better.

I began in December 2025 with no coding experience. I built full-time alongside full-time veterinary work, then moved to San Francisco in August 2026 to pursue go-to-market full-time. I still take clinical relief shifts: real appointments keep the product grounded.

Read the longer story