Software engineer building Recursive Language Model systems and the harnesses around them.
Persistent Python · recursive agents · memory · evaluation

Selected systems · Research notes · LinkedIn

I build agent runtimes that use persistent Python and recursive model calls to work beyond a single context window. I focus on making that work traceable, reproducible, and safe to approve.

Generating code got cheap. Knowing what to trust didn't.

I am open to software engineer roles with AI labs and research-driven startups, especially teams working on long-context inference, agents, evals, developer infrastructure, or human-AI collaboration.

Architecture overview only. Project links, maturity, and evidence are below.

The Recursive Language Models paper by Alex L. Zhang, Tim Kraska, and Omar Khattab describes an inference-time framework for long-context work. The input stays in an external environment where a model can inspect and transform it with code, keep intermediate state in a persistent REPL, and call language models recursively on selected pieces. The authors also publish the reference implementation. That idea is the spine of my current work.

I treat DeepSeek RLM and Recursus as two layers of the same evolving system. DeepSeek RLM is the preview execution layer for DeepSeek Harness: persistent IPython state, durable snapshots, native DSH child agents, and a Python tool bridge. Recursus is the in-progress product and assembly layer. Milestone 1 is implementing a reproducible assembly of that compute with a Codex provider, optional DeepSeek Honcho cross-session memory, Dovetail workflows, packaging, and verification. Future milestones add durable run supervision and routing. DeepSeek Harness remains the only agent loop and control plane.

Prime Agent from Prime Intellect provides the MIT-licensed prime-agent-runtime reused here and is the source of selected Jupyter transport and namespace-snapshot techniques. DeepSeek RLM vendors that runtime pin unmodified and adapts those techniques for DSH; it does not launch the Prime Agent application or a second agent loop. My contribution is the DSH-native integration: Cordis plugins, three proposed patches against the pinned DSH revision, lifecycle and security bounds, durable events, packaging, compatibility contracts, and verification.

Status and evidence: DeepSeek RLM is a preview for a patched DSH 0.1.0-rc.7; its CI, security boundary, and third-party provenance are public. Recursus is at Milestone 1 and has no release. Its specification, architecture, component manifests, and verification scripts are public. Honcho and Plastic Labs provide the optional, fallible semantic-memory service. The OpenCnid integration may send eligible bounded conversation text and sanitized cards to Honcho. Git and current files remain authoritative, and exact artifact bytes remain local.

TypeScript · Python · IPython · Cordis · DeepSeek RLM packages · Recursus component lock

Trellis was my earlier prototype for helping agents work over data larger than one context window while keeping every claim traceable to its source. It grew from a provenance-backed corpus substrate into a large-corpus RLM runtime built around the paper authors' MIT-licensed reference package. My additions include corpus ingestion, a Postgres and Neo4j provenance layer, bounded Trellis tools, caching and invalidation, and evaluation. It proved the direction and is a conceptual predecessor to Recursus, not a Recursus dependency.

Evidence: The pinned synthetic OOLONG-Pairs v1 report records two reported runs with an F1 score of 1.000 across all 20 queries, at total costs of $0.81 and $0.87. Run A has committed JSON evidence. Run B is preserved in the report from its console log. A harder v2 fixture exists but has not had a paid run.

TypeScript · Python · Postgres · Neo4j · Architecture · Pinned benchmark evidence

Symphony is a Rust implementation of the OpenAI Symphony orchestrator specification. It turns tracker issues into isolated agent runs, keeps scheduling state under one authority, prevents tracker credentials from entering the agent process, and cleans up workspaces when issues enter terminal states.

Try it: Clone Symphony and run make demo. The demo uses a local mock tracker and agent, so it needs no tracker account, agent credentials, or Codex installation. Its quick demo and conformance map show exactly what is exercised.

Rust · Tokio · MCP · HTTP · Specification · Tests

A strong model is one component. The surrounding system decides whether its work is useful:

• Bound the task. Define authority, evidence, budgets, and a machine-checkable finish line.
• Isolate execution. Give each run the minimum state and credentials it needs.
• Evaluate and trace. Use tests, graders, and adversarial cases that can fail. Keep the path from a conclusion back to source bytes and run evidence.
• Approve deliberately. Let supported output reach a human gate. Unresolved work retries.

That same pattern shows up from different angles in Dovetail, deepseek-dovetail, ralph-cli, openlog, and opentriage. The deepseek-dovetail behavioral report includes successful, unsuccessful, tied, and unmeasured results.

I read papers to decide what they justify building, not to decorate a bibliography. For each study, I publish detailed notes with page or section references and record both the supported design choices and the limits. llm-research-inspirations links seven paper studies to the systems they shaped. Four examples:

• deepseek-dovetail: prompting, delegation, evaluation, self-play, steering, and handoff workflows packaged for DeepSeek Harness.
• ralph-cli: repository scaffolding, architecture rules, drift detection, grading, and staged validation for agent-heavy development.
• fish-speech-go: a Go API server and streaming proxy around the Python Fish Speech inference backend.
• crawl-studio: a visual workspace for debugging selectors and seeing the content an extraction model receives.

I built my first PC in middle school so I could stream games on Justin.tv. Competitive gaming and coaching taught me to study systems, find leverage, review failures honestly, and help a team improve. I learned early web development around gaming communities, then kept following the problems that looked useful and difficult.

LLMs clicked for me when one solved a Codewars problem I was stuck on and explained several ways to think about it. I went from using the model, to scripting around the model, to building the environment the model works inside. Harness engineering feels like the natural next step on that path.

I am still a gaming nerd. I just spend far more time benchmarking agents now.

I am looking for a small, ambitious team where research, systems engineering, and product work overlap. If you are building agents and have reached the part where confident output is no longer the same thing as good output, I would like to talk.

Connect on LinkedIn or start a conversation on GitHub.