# Jordan Gibbs — Portfolio

> I’m a full-stack builder and AI consultant. I build and ship products, and I help companies put agents to work.

Full-stack builder and AI consultant. 12 projects. 3D site: https://jordangibbs.xyz/ · Simple list: https://jordangibbs.xyz/?view=list · This file: https://jordangibbs.xyz/portfolio.md

Contact: [Book a free call](https://calendly.com/jordanlgibbs/free-intro-getting-started-with-agents) · [Email me](mailto:jordan@jordangibbs.xyz) · [LinkedIn](https://www.linkedin.com/in/jordan--gibbs/)

## About

I build software end to end, from the backend and the agents inside it to the interface and the deploy, and I ship it. The other tapes on this shelf are things I built: a deep research engine that ranks first on DRACO, an on-device dictation app, fine-tuned models, research tooling and production platforms for clients. As an AI consultant I run Agent Sessions, which put Claude Code, Claude Cowork and OpenAI Codex to work for a team, and I work as a fractional CAIO for owner-run businesses. I also write about these tools on Medium.

**Skills:** Full-stack development, Product engineering, Agent orchestration, Multi-agent systems, LLM fine-tuning, RAG & retrieval, Evals & benchmarking, Low-latency systems, Sandboxed infrastructure, MCP server design, Agent adoption, Technical writing

**Tech:** Python, TypeScript, Rust, React, FastAPI, Claude Code, Claude Cowork, OpenAI Codex, MCP, Cloudflare

## Projects

| # | Project | Area | Year | Status | One line |
|---|---|---|---|---|---|
| 01 | Hyperresearch | Deep Research | 2026 | Live | Deep research that ranks first on DRACO and checks every citation. |
| 02 | Ochre | Voice Dictation | 2026 | Open source | On-device dictation that types your words 150 ms after you let go. |
| 03 | Agent Sessions | Agent Adoption | 2026 | Booking | AI agents set up on your team’s real work, with guardrails. |
| 04 | Medium | Writing | 2023–present | Published | Plain-English writing on AI for real work, read by 1.6M people. |
| 05 | Pi Swarm | Multi-Agent | 2026 | Lab | One session running up to 100 coding agents in the cloud. |
| 06 | Frank 27B | Fine-Tuned LLM | 2026 | Lab | Plainspoken AI. |
| 07 | Thalient Labs | Ternary LLMs | 2026 | Research | Training LLMs whose weights are −1, 0 or +1. |
| 08 | Wiki Grounding | Grounded QA | 2026 | Research | An agent that searches all of Wikipedia before it answers. |
| 09 | Solo Business Agent | Custom Integrations | 2026 | Live | One agent wired into an owner’s tools, rules and customers. |
| 10 | Firm Agent Platform | Document Agents | 2026 | Client work | Agents that read every page and cite the page they used. |
| 11 | Concordance | Legacy Modernization | 2026 | Client work | Turns old code into a spec that cites every line. |
| 12 | Government Coding Agent | Agent Pipeline | 2026 | Client work | An agent pipeline from spec to deployed software. |

### 01 · Hyperresearch

*Deep Research · 2026 · Live*

**Deep research that ranks first on DRACO and checks every citation.**

A deep research engine that ranks first on the DRACO benchmark, ahead of Claude Research, ChatGPT, Gemini and Perplexity. A Deep report reads more than 200 sources and has its citations checked against the sources before it is released. Its Answers API, which gives an agent one checked, quoted answer per question, ranks first against the other web search and answer APIs. It is open source with 3.9k GitHub stars, and runs as a paid hosted service at hyperresearch.ai.

**Links:** [Visit hyperresearch.ai](https://hyperresearch.ai/) · [GitHub](https://github.com/jordan-gibbs/hyperresearch) · [DRACO results](https://hyperresearch.ai/benchmarks/draco) · [Answers API](https://hyperresearch.ai/answers)

**Skills:** Agent orchestration, Multi-agent pipelines, Citation verification, Deep research, Evals & benchmarking, Retrieval & search ranking, MCP server design, Prompt-injection defense, Durable workflows, Usage-based billing, Open-source maintenance, Cost controls

**Tech:** Python, Claude Code, OpenAI Codex, MCP, SQLite, Cloudflare

Write-up: https://jordangibbs.xyz/projects/hyperresearch.md · In the 3D room: https://jordangibbs.xyz/#/hyperresearch

#### Highlights

- First on the DRACO deep research benchmark at 77.7, ahead of Claude Research (73.0), Perplexity (57.8), ChatGPT (55.2) and Gemini (54.7)
- A Deep report reads more than 200 sources and checks 96 figures, and a quote that isn’t in its source stops the report from shipping
- The [Answers API](https://hyperresearch.ai/answers) ranks #1 against every other web search and answer API: one call returns one answer with the quotes it rests on, each checked against its page
- Open source under MIT with 3.9k GitHub stars, and live as a paid service at hyperresearch.ai

#### What it is

Hyperresearch takes one question and writes a long, argued report, along with a record of every source it read, the passage each citation depends on, and a verdict on whether that passage supports the sentence citing it. I built it because the deep research tools I used wrote well and cited badly. They attributed quotes to sources that never contained them, cited papers after reading only the abstract, and counted five reprints of one press release as five sources.

It runs as a skill in Claude Code or OpenAI Codex, and as a managed service at [hyperresearch.ai](https://hyperresearch.ai/) with a console, an API and a hosted MCP server.

#### How a run works

A full run has 16 steps, and each step’s instructions load only when that step starts, because a long pipeline held in context all at once tends to skip steps. Sources come from the open web and from scholarly and data sources such as OpenAlex, Crossref, SEC EDGAR and FRED. A contradiction graph marks where the evidence conflicts, and investigators work through each conflict. Three drafts are synthesized into one, four critics review it in parallel, and a patcher that only has Read and Edit applies their fixes, so it can’t regenerate the report and lose earlier work. Last, a cite-checker goes back to the sources, and a quote that isn’t there word for word blocks the report.

Paywalled papers are swapped for legal open-access copies, with every swap disclosed, and reprints count once. Everything read goes into a markdown vault with a SQLite index that later questions search first. Fetched pages are fenced as untrusted, so instructions planted in a page are ignored.

#### Results

DRACO is a benchmark from Perplexity and Harvard. I ran 10 tasks across 10 domains and graded every system with the same judge:

| System | DRACO mean |
|---|---|
| **Hyperresearch Deep** | **77.7** |
| Claude Research (Opus) | 73.0 |
| Parallel Ultra | 61.5 |
| Perplexity Deep Research | 57.8 |
| ChatGPT Deep research | 55.2 |
| Gemini Deep Research | 54.7 |

These are my own measurements, not an official leaderboard, and the [method is published](https://hyperresearch.ai/benchmarks/draco). Unedited sample reports are free to read: [Toast vs Square vs Clover](https://hyperresearch.ai/samples/restaurant-pos-competitor-analysis), [Buying a $2M HVAC business](https://hyperresearch.ai/samples/buying-an-hvac-business) and [Who is winning AI coding agents](https://hyperresearch.ai/samples/ai-coding-agents).

#### Answers API: #1 in web search

The [Answers API](https://hyperresearch.ai/answers) takes the same engine and points it at the questions agents ask all day, the ones with a single right answer. It ranks #1 against every other web search and answer API, including Exa and Parallel, with each provider given the same agent and the same questions in the open-source Artificial Analysis Search Index harness.

Most search APIs hand an agent a pile of links and leave the reading to it. Answers does the reading on its side. An agent makes one `ask` call instead of thirty searches, and gets back a short answer plus the quotes it rests on, so no pages flood its context. Behind that one call:

- **The open web and about 45 structured sources.** Every call also queries the records that fit the question: SEC EDGAR, Companies House and GLEIF for companies; FRED, Eurostat, the World Bank and the IMF for statistics; OpenAlex, PubMed and arXiv for papers; the Federal Register, eCFR and Congress.gov for government; plus books, research funding, GitHub, Stack Exchange and Wikipedia. There’s no source to pick and no extra key to hold.
- **Every quote checked.** Each passage is matched word for word against the page it came from, and the answer is checked against the quotes. A passage that doesn’t match is marked unverified.
- **An honest not found.** When nothing supports an answer, `ask` returns `not_found` instead of a guess, and a not-found costs as little as a fifth of the call. A failure on our side costs nothing.
- **Raw sources when you want them.** `search` returns ranked sources with the matching passages copied word for word, with no summary or rewriting.

It runs as a remote MCP server at `answers.hyperresearch.ai`, so one command connects Claude Code, Cursor, VS Code, Windsurf or ChatGPT:

```bash
claude mcp add --transport http -s user hyperresearch-answers https://answers.hyperresearch.ai/mcp
```

Calls are priced by the question, from 5¢ for a fast `ask`, and every account gets $5 of free credit with no card needed.

#### Run it yourself

```bash
pip install hyperresearch
hyperresearch install            # then, in Claude Code: /hyperresearch <question>
```

The hosted version runs Light reports for $9 and Deep reports for $49, and your first Deep report is free.

### 02 · Ochre

*Voice Dictation · 2026 · Open source*

**On-device dictation that types your words 150 ms after you let go.**

I was tired of paying for Aqua Voice, so I built a free, open-source alternative to subscription dictation apps for Windows, macOS and Linux. Speech recognition runs on your own machine, and so do the cleanup models I fine-tuned for it. The text appears about 150 ms after you release the key, and there is no account, no telemetry and no audio written to disk.

**Links:** [Download the latest release](https://github.com/jordan-gibbs/ochre/releases/latest) · [GitHub](https://github.com/jordan-gibbs/ochre) · [Models on Hugging Face](https://huggingface.co/polonuim210)

**Skills:** Speech recognition, ASR model benchmarking, LLM fine-tuning, Synthetic error simulation, Low-latency systems, Streaming decode, Wake-word training, Blind evals, Desktop app development, Cross-platform text injection, On-device inference, Open-source release

**Tech:** Rust, Tauri, ONNX Runtime, Qwen3.5, Hugging Face

Write-up: https://jordangibbs.xyz/projects/ochre.md · In the 3D room: https://jordangibbs.xyz/#/ochre

#### Highlights

- Text appears about 150 ms after you release the key, and 218 ms at the 95th percentile with the machine under load
- Speech recognition and cleanup both run on your own machine, the cleanup on three models I fine-tuned and published on Hugging Face
- Free and MIT-licensed, with installers for Windows, macOS and Linux

#### What it is

I was tired of paying for Aqua Voice every month, so I built my own. Ochre is a free, local alternative to subscription dictation apps like Aqua Voice and Wispr Flow. You hold a key, talk and let go, and Ochre types what you said into whichever text box has focus. There is no account and no telemetry, and no audio is written to disk.

#### Where the latency was

A speech model that benchmarks at 200 ms on an idle machine can take seconds inside a real app, and very little of that time is in the model. Decoding waited for the key release, threads spun while the OS scheduled something else, and short sleeps on Windows rounded up to the 15.6 ms timer tick. Ochre now decodes while you talk, keeps a short pre-roll so the first syllable isn’t clipped, runs the decode thread at raised priority and types before it saves anything. The median from release to text is 143 ms.

#### The models

I benchmarked eight local speech models on read speech, meetings and earnings calls, using a WER that also counts case and punctuation. Parakeet TDT 0.6B v3 won with a 5.5% average WER, 25 languages and its own punctuation, and runs on ONNX Runtime from Rust.

The optional cleanup pass removes filler, applies spoken corrections like “no wait, make that Tuesday” and writes numbers the way you would type them. It runs on **Ochre Refine 4B, 2B and 0.8B**, Qwen3.5 fine-tunes trained on real recognizer output plus a simulator of the recognizer’s mistakes. On 773 held-out dictations judged blind they pass 80%, 71% and 64% of the time, and a guard falls back to your raw words if a model rewords what you said. A wake word I trained lets you dictate hands-free.

#### How it’s built

One Rust process of nine crates covers audio, speech, cleanup, the wake word and text injection, with Tauri for the UI. Ochre sends native keystrokes on Windows, uses `xdotool` on X11 and `ydotool` on Wayland, and pastes long passages before restoring your clipboard.

#### Links

- [Download v0.1.0](https://github.com/jordan-gibbs/ochre/releases/latest)
- [Source on GitHub](https://github.com/jordan-gibbs/ochre)
- [Ochre Refine models on Hugging Face](https://huggingface.co/polonuim210)

### 03 · Agent Sessions

*Agent Adoption · 2026 · Booking*

**AI agents set up on your team’s real work, with guardrails.**

Hands-on sessions where I install Claude Cowork, Claude Code and OpenAI Codex inside a business, build its first workflows on real work and set the guardrails. I have done this for dozens of companies, including venture firms, legal teams and government, and across those engagements people get back about 7 hours a week and 9 in 10 teams are still using their agents a month later. Every engagement starts with a free plan and a free call.

**Links:** [Visit agents.jordangibbs.xyz](https://agents.jordangibbs.xyz/) · [Get your free agent plan](https://agents.jordangibbs.xyz/planner) · [Book a free Primer call](https://calendly.com/jordanlgibbs/free-intro-getting-started-with-agents)

**Skills:** Agent adoption, Workflow design, Workflow automation, Guardrails & permissions, Tool installation & setup, Systems integration, Approval flows, Team training, Change management, Rollout planning, Rules engines, Impact measurement

**Tech:** Claude Cowork, Claude Code, OpenAI Codex

Write-up: https://jordangibbs.xyz/projects/agent-sessions.md · In the 3D room: https://jordangibbs.xyz/#/agent-sessions

#### Highlights

- Dozens of companies helped, from venture firms and legal teams to government
- 7 hours back per person each week
- 9 in 10 teams still using their agents a month later
- Up to 9× faster on the hardest workflows

#### What this is

I put Claude Cowork, Claude Code and OpenAI Codex to work on the jobs a team already does every week, like working through the inbox, handling intake or rebuilding the same report every Monday. What decides whether the agents are still running a month later is someone sitting with the team, installing the tools properly and building the first workflows on real work.

#### The sessions

| Session | Length | What you leave with |
|---|---|---|
| **Primer** | 30 min · free | Where agents fit your business and a clear first step |
| **Launchpad** | ~3 hours · your team | Tools installed, connected to your stack, with permissions and safe defaults |
| **Buildout** | ~6 hours · team and workflows | Launchpad plus real workflows built end to end, approvals and a clean handoff |

Every engagement starts with a Primer, then one hands-on session on your real work and 30 days of support. I never process or store your data, since everything runs directly through Anthropic or OpenAI, and permissions match your level of risk from the first day.

#### The Agent Starter Planner

Answer about 30 questions and the free planner tells you which agent to start with, what it costs and the hours it should give back, with a map of your systems, a playbook for every role and a 90-day rollout. It takes two to seven minutes with no account. Every recommendation comes from a rules engine I wrote, so it traces back to your answers.

> The numbers above are averages across my past client engagements.

#### Links

- [agents.jordangibbs.xyz](https://agents.jordangibbs.xyz/)
- [Get your free agent plan](https://agents.jordangibbs.xyz/planner)
- [Book a free 30-minute call](https://calendly.com/jordanlgibbs/free-intro-getting-started-with-agents)

### 04 · Medium

*Writing · 2023–present · Published*

**Plain-English writing on AI for real work, read by 1.6M people.**

Essays and beginner’s guides on ChatGPT, Claude Code, Claude Cowork and OpenAI Codex, read by 1.6M people and followed by more than 19,000. My most-read story has 26K claps and more than 1,200 responses.

**Links:** [Read on Medium](https://medium.com/@jordan_gibbs) · [Read the most-read story](https://medium.com/@jordan_gibbs/chatgpt-is-poisoning-your-brain-b66c16ddb7ae)

**Skills:** Technical writing, Plain-English explanation, Prompt engineering, Beginner’s guides, Long-form essays, Teaching non-technical readers, Headlines & hooks, Editing, Audience growth, Agent workflows, Hands-on tool testing

**Tech:** ChatGPT, Claude Code, Claude Cowork, OpenAI Codex

Write-up: https://jordangibbs.xyz/projects/medium.md · In the 3D room: https://jordangibbs.xyz/#/medium

#### What I write

I write short, plain-English pieces on what works with AI tools, for people who use them for real work. I started with ChatGPT prompts in 2023 and now write full beginner’s guides to the agents I set up for clients. What I learn in [Agent Sessions](https://agents.jordangibbs.xyz/) usually ends up in the next guide.

#### Most-read stories

- [ChatGPT Is Poisoning Your Brain…](https://medium.com/@jordan_gibbs/chatgpt-is-poisoning-your-brain-b66c16ddb7ae), 26K claps
- [The Only ChatGPT Prompt that Matters.](https://medium.com/@jordan_gibbs/the-only-chatgpt-prompt-that-matters-f16dd85e43b3), 6.8K claps
- [The Most Important ChatGPT Prompt](https://medium.com/@jordan_gibbs/the-most-important-chatgpt-prompt-55ef2bdc4d4a), 4.7K claps

#### The agent guides

- [Claude Code](https://medium.com/@jordan_gibbs/the-ultimate-beginners-guide-to-claude-code-4d5763021199)
- [Claude Cowork](https://medium.com/@jordan_gibbs/claude-cowork-the-definitive-beginners-guide-e5b13476229e)
- [OpenAI Codex](https://medium.com/@jordan_gibbs/openai-codex-the-definitive-beginners-guide-8b72430645e6)

### 05 · Pi Swarm

*Multi-Agent · 2026 · Lab*

**One session running up to 100 coding agents in the cloud.**

An orchestration layer that lets a single agent session in pi, Claude Code or Codex run up to 100 coding agents at once, each in its own cloud sandbox. Spending caps are enforced in code instead of in the prompt, a dead-man’s switch shuts every worker down if the session dies, agents can send each other mail, and a whole run can be rebuilt from the cloud if the local record is lost.

**Links:** [Built on pi](https://github.com/earendil-works/pi)

**Skills:** Agent orchestration, Multi-agent systems, MCP tool design, Cloud sandboxing, Distributed systems, Spend caps in code, Inter-agent messaging, Watchdogs & dead-man switches, Fault tolerance, Run recovery, Concurrency control

**Tech:** TypeScript, pi, MCP, Daytona, Docker, Claude Code

Write-up: https://jordangibbs.xyz/projects/pi-swarm.md · In the 3D room: https://jordangibbs.xyz/#/pi-swarm

#### Highlights

- One session in pi, Claude Code or Codex can run up to 100 coding agents, each in its own cloud sandbox
- Spending caps are enforced in code, and workers shut down if the coordinating agent goes quiet
- About 4,800 lines of TypeScript, with end-to-end tests that run real pi workers and Claude Code as the brain

#### What it is

[pi](https://github.com/earendil-works/pi) is a deliberately minimal open-source coding agent that ships without sub-agents. Pi Swarm is an extension that turns one pi session into a **brain** that hands work to as many as a hundred **workers**, each a Daytona sandbox or local Docker container running its own copy of pi. The swarm is also exposed over MCP, so Claude Code or Codex can be the brain.

Starting many agents is easy. Keeping them under control is harder, because spend runs away, orphaned sandboxes bill overnight and the lead agent burns its context polling workers. I solved each of those in code instead of warning the model in a prompt.

#### Keeping it under control

- **Caps in code.** A governor refuses any spawn past 100 workers, $50 a run or $20 an hour, and each worker is held to 150 turns and $2. A run can lower these limits but can’t raise them.
- **A dead-man’s switch.** Sandboxes stop after 20 minutes without hearing from the brain, so if the brain crashes the swarm shuts itself off.
- **Private keys.** API keys never appear in a tool result, log or report, and each worker gets only its own provider’s key.
- **A brain that never blocks.** Every tool returns in under two seconds, progress arrives as one batched message, and a hook blocks sleep-and-poll loops.

#### How it works

The brain and workers meet only at a file protocol. The brain drops pi RPC commands into a worker’s inbox as JSON, and the worker atomically rewrites a small `state.json` and a heartbeat on every event. Mail between agents uses the same protocol and is relayed through the brain, so the brain sees every message and a worker can’t forge the sender.

```
[mail from w-003 · request · m-…] need the schema w-001 settled on
```

Every sandbox is labelled with its run and worker id, so if the local record is lost, `swarm_resume` rebuilds the whole run from Daytona. Pi Swarm is a private lab project at v0.1.0, and workers can run DeepSeek V4.1 Flash or Meta’s Muse Spark models.

#### Links

- [pi, the agent it’s built on](https://github.com/earendil-works/pi)

### 06 · Frank 27B

*Fine-Tuned LLM · 2026 · Lab*

**Plainspoken AI.**

A Qwen3.8-27B fine-tune that answers in plain, direct English without a preamble or stock AI phrasing, while keeping the detail a harder question needs. In a blind check against its own base model it was preferred on 20 of 28 pairs, cut material failures from 7 to 3 and hit the requested voice 20 times to the base’s 2. It was LoRA-trained on 4,243 curated conversations in under two hours on one H200.

**Skills:** Fine-tuning, LoRA training, Synthetic data generation, Data curation, Dataset auditing, Voice & style specs, Evals, Blind review, Checkpoint selection, GPU training runs, Model serving, Agent-run data pipelines

**Tech:** Qwen3.8-27B, LoRA, vLLM, H200, Daytona, Python

Write-up: https://jordangibbs.xyz/projects/frank-27b.md · In the 3D room: https://jordangibbs.xyz/#/frank-27b

#### Highlights

- A Qwen3.8-27B fine-tune that answers in plain, direct English, without losing the detail a hard question needs
- Preferred over its own base model on 20 of 28 pairs in a blind check, with material failures down from 7 to 3 and the requested voice hit 20 times to the base’s 2
- LoRA-trained on 4,243 curated conversations in 1 hour 40 minutes on a single H200

#### Why I built it

Most chat models answer a simple question with a preamble and a summary, and when told to be concise on a hard one they cut the part that explains the answer. I wanted a model that answers in a few words when that is enough and walks through the full mechanism when the question needs it.

#### The data

I read model answers in a small review tool I built, marked what I liked and disliked, and turned the notes into writing rules over seven versions. The rules go to the model that writes the training examples and never appear in the conversations, so Frank learns the voice as its default instead of as an instruction.

Agents generated the tasks and answers, and reviewers read every answer in full. A later audit of all 4,161 conversations repaired 102, dropped 12 and added 94.

#### Training

I trained a LoRA adapter (rank 32, alpha 64, about 233M trainable parameters) on a pinned Qwen3.8-27B, with loss only on the assistant’s final answer. One epoch of 266 steps took about an hour and forty minutes on one H200 in a Daytona sandbox. The final checkpoint often returned empty answers in thinking mode, so I kept checkpoint 50, which completed all 44 thinking answers and passed 38 of 40 low-thinking answers against the base’s 36.

#### The blind check

I wrote 24 new scenarios and ran Frank and the unchanged base with the same settings and no style prompt. A model reviewer rated every answer and sealed its ratings before it learned which model wrote which.

| 28 non-thinking answers each | Frank | Base |
|---|---:|---:|
| Pass | 16 | 12 |
| Minor issue | 9 | 9 |
| Material failure | 3 | 7 |
| Fits the requested direct voice | 20 | 2 |

![Before and after: Frank removes the preamble and keeps the location, deadline and request.](https://jordangibbs.xyz/projects/img/frank-27b-rewrite.png)

The prompted base produced the same rewrite for this example, so it shows how Frank behaves rather than a win over the base.

#### Limits

Frank still makes mistakes, such as one explanation saying 0.81 + 0.18 is 98%. The tests are small and model-reviewed, so they show a recognisable, useful voice and say nothing about general intelligence or coding. Frank is an experimental v0.1 and hasn’t been published yet.

### 07 · Thalient Labs

*Ternary LLMs · 2026 · Research*

**Training LLMs whose weights are −1, 0 or +1.**

My research lab for LLMs whose weights are only −1, 0 or +1, with the experiments designed and launched by a swarm of Claude Code agents. Its BLITZ training recipe cut 7B perplexity by 38% against standard ternary training on a single B200, running ternary training on FP4 tensor cores made it 3× faster than BF16 at 7B, and a hand-written C engine runs a 1B ternary architecture at 900 tokens per second on one server CPU.

**Links:** [Visit thalientlabs.ai](https://thalientlabs.ai/)

**Skills:** Ternary (1.58-bit) LLM training, Quantization-aware training, Training-recipe design, Optimizer scheduling (NorMuon, AdamW), FP4 tensor-core training (NVFP4), Single-GPU 7B training (B200), Perplexity benchmarking, C inference engines, AVX-512 VNNI kernels, Speculative decoding, Agent swarms (Claude Code), Research lab leadership

**Tech:** PyTorch, NVFP4, B200, C, AVX-512, Claude Code

Write-up: https://jordangibbs.xyz/projects/thalient-labs.md · In the 3D room: https://jordangibbs.xyz/#/thalient-labs

#### Highlights

- LLMs whose weights are only −1, 0 or +1, trained in ternary from the first step
- BLITZ, a training recipe that cut perplexity by 38% against the standard method at 7B, on a single B200
- Ternary training on FP4 tensor cores at 3× the throughput of BF16 at 7B, with zero added rounding error

![{ -1, 0, +1 }](https://jordangibbs.xyz/projects/img/thalient-labs-ternary.png)

#### What it is

Thalient Labs is my research lab for ternary neural networks. A ternary weight takes 1.58 bits instead of 16, every multiplication becomes an add, a subtract or nothing, and about a third of the weights end up as zero. A brain runs on 20 watts, and I think most of the gap to a frontier model is an engineering problem.

Most experiments are run by Thalient Swarm, my platform of Claude Code agents. They write and launch each experiment on cloud GPUs and bring me proposals, and I decide what runs next.

#### What I found

- **The collapse at λ≈0.7.** When ternary is phased in, the gradients of every layer line up at about 70% strength and the loss explodes. Letting each layer ternarize at its own pace took a Qwen3-0.6B conversion from a perplexity of 1.8 million to 25.75.
- **The standard scale is 35% too small.** AbsMean averages in the zero weights. Multiplying it by 1.35 improved perplexity by 5.5% at 7B.
- **Ternary fits FP4 exactly.** After block scaling, −1, 0 and +1 are exact in NVIDIA’s FP4 format, so Blackwell’s FP4 tensor cores train ternary with no rounding error, at 54,300 tokens per second against 18,200 for BF16.

#### BLITZ

BLITZ combines these findings. It trains in full precision with the NorMuon optimizer for the first 45% of tokens, then blends into ternary with AdamW, using the corrected scale and FP4 throughout.

| 7B, 500M tokens, one B200 | Perplexity |
|---|---|
| Standard ternary (STE + AdamW) | 91.15 |
| **BLITZ** | **56.16** |

#### Running on a CPU

A 1B ternary model is about 200 MB, small enough to stay in a server CPU’s cache. I wrote the inference engine in C with AVX-512 VNNI, storing weights at 2.5 bits and decoding them for free behind memory latency. It runs as the draft model in speculative decoding, with a full model on the GPU checking its guesses.

| 1B ternary architecture | Tokens per second |
|---|---|
| AMD EPYC Genoa, one instance | 900 |
| AMD EPYC Genoa, three instances | 1,912 |
| Ryzen 7 9800X3D desktop | 622 |

#### Links

- [thalientlabs.ai](https://thalientlabs.ai/)

### 08 · Wiki Grounding

*Grounded QA · 2026 · Research*

**An agent that searches all of Wikipedia before it answers.**

All 6.6M pages of English Wikipedia indexed as 30.9M searchable passages, and an agent that has to search them before it answers. On SimpleQA Verified it took a 27B open model from 7.5% to 81.2% accuracy and cut its hallucination rate from 98.7% to 11%, at about a quarter of the cost per question. I built it because an LLM with the right tools can do far more than its baseline suggests.

**Skills:** Retrieval-augmented generation, Agentic search & tool use, Hybrid retrieval (dense + BM25), Embedding pipelines (EmbeddingGemma), Structure-aware chunking, Large-scale indexing (30.9M passages), Memory-mapped serving (Apache Arrow), Fault-tolerant GPU batch jobs, LLM evals (SimpleQA, AA-Omniscience), LLM-as-judge grading, Hallucination reduction, Prompt engineering

**Tech:** Python, EmbeddingGemma, Tantivy BM25, SQLite, Apache Arrow, Daytona GPUs

Write-up: https://jordangibbs.xyz/projects/wiki-grounding.md · In the 3D room: https://jordangibbs.xyz/#/wiki-grounding

#### Highlights

- All of English Wikipedia indexed as 30.9 million searchable passages, with a 27B open model given three tools to read it
- On SimpleQA Verified, accuracy went from **7.5% to 81.2%** and wrong answers fell from **913 to 21** out of 1,000
- Cut the hallucination rate from 98.7% to 11%

#### Why I built it

A language model on its own is only as good as what it memorized. Give it the right tools, a real library and the discipline to check it before it answers, and the same model gets far better than its baseline suggests. I built this to measure exactly how far good tooling can take one.

#### The problem

Ask a 27B open model a long-tail factual question with no tools and it will almost always answer, and almost always be wrong. On SimpleQA Verified it attempted 988 of 1,000 questions, got 913 wrong and said "I don't know" twelve times. The standard fix is retrieval, and I wanted to measure which version of it helps, what it costs and where it stops helping.

#### The library

I started from FineWiki English, 6,614,655 pages and 35.1 GB of parquet. Every article is cut along its section tree into chunks under 1,000 tokens, and each chunk starts with its address (`Title > Section > Subsection`) so it makes sense on its own. Meaning is searched through 256-d EmbeddingGemma vectors, exact names and numbers through a Tantivy BM25 index, and a SQLite corpus holds sections, infoboxes, tables and aliases mined from link anchors.

The build ran on Daytona spot GPUs, and every step is written so that losing a GPU costs one shard instead of the run. The result is **30,928,570 passages**, served from a memory-mapped Arrow file after my first in-memory attempt killed a 55 GB machine.

#### The agent

The model gets three tools (`search`, `read` and `find_in_article`) and eight calls per question. The median search took 149 ms, and a typical question used 3.4 tool calls and finished in 13 seconds.

#### Results

| Run | Correct | Wrong | Abstained | Hallucination |
|---|---|---|---|---|
| SimpleQA Verified, closed-book | 75 | 913 | 12 | 98.7% |
| SimpleQA Verified, tools | 811 | 71 | 118 | 37.6% |
| SimpleQA Verified, strict | 812 | 21 | 167 | **11.2%** |
| AA-Omniscience, closed-book | 92 | 117 | 386 | 23.0% |
| AA-Omniscience, tools | 140 | 265 | 178 | 57.6% |
| AA-Omniscience, strict | 106 | 55 | 427 | **11.1%** |

When the answer is in Wikipedia, looking it up wins easily. Accuracy rose elevenfold and the cost per question fell from $0.0163 to $0.0041, because a model that can check a fact stops spending tokens reasoning toward a guess.

Specialist questions went the other way at first. Plain tool use more than doubled the wrong answers on AA-Omniscience, and 200 of those 265 errors came after the model had used all eight calls, found nothing and answered anyway. The strict setting tells the model to answer only from what it found. That turned 216 of those late guesses into "I don't know" and moved the Omniscience Index from −20.8 to +8.5.

The 3,200 graded questions across six runs finished with zero errors for about $41. Each configuration was run once, and I graded with the standard simple-evals grader, so the numbers can't be compared directly with the public leaderboard.

### 09 · Solo Business Agent

*Custom Integrations · 2026 · Live*

**One agent wired into an owner’s tools, rules and customers.**

A business agent I build around one owner, connected to all of his tooling and set up around how his business actually runs. It plugs into his email accounts, calendar, spreadsheets and business phone line, sorts every customer message into one of twenty categories, and works each one through a workflow built for his business. His business rules live inside it: what it can answer, which prices it can quote, and what must always come back to him, like a custom quote or a deadline. It learns as he uses it, turning every edit and rejection into a rule it follows next time. The first went from an empty repo to production in two weeks.

**Skills:** Custom tool integrations, Workflow design, Business-rule policy, Customer messaging, Learning from corrections, Human-in-the-loop approvals, Agent guardrails, Rate limiting, Google OAuth + APIs, Webhooks + cron, Container deployment, Phone-first PWA

**Tech:** TypeScript, Pi agent SDK, Cloudflare Containers, Hono, D1 · R2, React, Gemini Flash

Write-up: https://jordangibbs.xyz/projects/understudy.md · In the 3D room: https://jordangibbs.xyz/#/understudy

#### Highlights

- A business agent I build and deploy for one owner, wired into all of his tools: every email inbox, his calendar, his spreadsheets and his business phone line
- His business rules live inside it: twenty kinds of customer message, each with its own workflow and its own policy for what the agent may say
- It learns as he uses it, turning every edit and every rejection into a rule it follows next time
- Live in production, answering real customers. The first deployment went from an empty repo to live customers in two weeks and 72 commits

#### What it is

The agent sits on top of everything the owner already uses to run his business. It reads every inbox and every customer text, keeps the calendar, handles each customer conversation the way that business handles it, and sends one short update an hour with whatever needs a decision. For most messages the owner's part is reading a draft on his phone and tapping Approve.

The core agent is the same for every client. What changes is the setup: which tools it connects to, which workflows it runs, what it may say, and which questions it hands back. When the agent doesn't know something, it asks the owner instead of guessing.

#### Connected to his tools

The owner's email accounts, calendar, business phone line and reference sheets, such as a price list, plug in as the agent's tools, each through its own client. A new text on the business line reaches the agent by webhook with the whole conversation in view, and every customer gets a running summary of the conversation so far that the owner sees on every card that needs him. The next connection on the list is email to calendar, so a booking that arrives by email lands on the calendar without anyone retyping it.

#### His business rules, built in

Incoming messages are sorted into twenty categories, from FAQs and listed prices to custom quotes, order status and calendar requests, and each category runs its own workflow with its own policy: draft for approval, never answer, or send on its own once the owner trusts it. Business facts go into a knowledge pack, so a draft quotes what's true for that business. If the answer depends on something the agent can't see, like a custom quote, a deadline or where an order stands, the question goes straight to the owner.

#### It learns as he uses it

Every edit, every rejection with its reason and every email draft he rewrites before sending goes into one ledger. Once a day a model call turns new entries into a short playbook of rules that every drafting prompt reads, so a correction made on Monday shapes Tuesday's drafts. Rules the owner writes himself are kept word for word. The tone guide was built from his real message history, so replies read like his, and a guard holds back any draft that slips into talking like a machine.

#### Staying out of the owner's way

Writing a good reply was the easier problem. Most of the engineering went into not sending something it shouldn't.

- **The owner answered first.** A hand-written reply withdraws the agent's draft, checked at approval, on the delivery webhook and on a five-minute sweep.
- **Send limits.** A hard cap of 30 texts and 30 emails in any rolling hour, after which sends are refused, logged and reported to the owner.
- **Restarts and stale drafts.** Drafts in flight during a restart are recovered from the database, and email drafts left unsent for 7 days are deleted.

#### How it's built

The agent runs on the Pi agent SDK inside a Cloudflare Container, one session per thread, because it needs a real filesystem and a long-lived process. Three Hono Workers sit around it, with D1 holding approvals, policy and the audit log and R2 holding session backups. The model is Gemini Flash with context caching, switchable to Claude with one setting, and the front end is a phone-first React app built with assistant-ui.

It has been live since the end of September.

### 10 · Firm Agent Platform

*Document Agents · 2026 · Client work*

**Agents that read every page and cite the page they used.**

A bespoke agent platform built for a professional-services firm and running in production. Every file dropped into a case is indexed, so the agent can pull facts out of PDFs that run to hundreds of scanned pages and back each one with a receipt: the exact file and page it came from. It processes hundreds of thousands of PDF pages a month across hundreds of cases and saves the firm hundreds of hours every month. Each case runs in its own sealed container, with gates that send the agent back until every record is indexed and every line of its output is sourced.

**Skills:** Agent harness design, Subagent orchestration, Document indexing, Long-PDF extraction, Citation provenance, Deterministic output gates, Container sandboxing, Egress lockdown, Crash recovery, Chaos testing, Template filling (Word + Excel), Streaming web app

**Tech:** Python, FastAPI, Docker, SQLite, React, TypeScript

Write-up: https://jordangibbs.xyz/projects/casefile.md · In the 3D room: https://jordangibbs.xyz/#/casefile

#### Highlights

- A bespoke agent platform I designed and built for a professional-services firm, running in production as the team's daily tool
- Every file in a case is indexed, so the agent can extract from PDFs hundreds of scanned pages long and hand back receipts: each fact tied to the exact file and page it came from
- It processes **hundreds of thousands of PDF pages a month across hundreds of active cases**, and saves the firm **hundreds of staff hours a month**
- Each case gets its own sealed container running a full coding agent with up to ten subagents
- Automatic gates send the agent back to work until every record is indexed and every line of output cites its source page

*Client work under NDA, so the client and the data stay unnamed and the details are kept general.*

#### What it does

A case arrives as a pile of paper: hundreds of PDFs, many scanned and some handwritten, plus spreadsheets and half-finished Word drafts. Staff drop the pile into the case and ask for the work in plain English. The agent produces what the team used to assemble by hand, including an index of every record, an appendix that cites each one to the page, a chronology, deduplicated record sets and workbooks with live formulas, all filled into the firm's own templates. On a normal weekday five to ten cases have an agent working at once, and the platform has peaked at 13.

I built the platform, the agent harness, the web app, the infrastructure and the test suites. The harness alone is about 70k lines across 157 commits in five months.

#### Why it's hard

The job needs an agent that can open files, write Python, build a workbook and check its own output, so a chat-with-your-PDF tool can't do it. That agent also has to be **unable to reach the internet, unable to see another case, and unable to make things up**, and it has to keep working through 300 MB scans, restarts and network drops.

I took a stock open-source coding agent and restricted it until the only thing it could do was document work on one case's files. Nearly all of the engineering is in the harness around it.

```
browser ──► platform   (always on: turn engine · gates · memory governor · scoped-token proxy)
              ▼
            sealed container, one per case   (sleeps when idle)
              conductor + up to 10 subagents · Python document toolkit
              /workspace = this case only · house templates mounted read-only
              ▼
            egress to one approved model endpoint only, with the public internet firewalled off
```

A case is a folder on an encrypted disk, holding atomic JSON files, a SQLite session history and an audit log the agent can't see, so exporting a case means zipping a folder. Each container has no capabilities, a read-only root and capped memory. A fake metadata server gives the agent a token that can call the model and nothing else, so even a prompt-injected agent can't borrow the machine's identity.

#### Indexing, long PDFs and receipts

The first thing the agent does with a new pile is index it. Every upload is hashed and its pages counted into a manifest the platform owns, and the agent builds its own index of every record against it, so nothing in the case is invisible to later work. Long scans are cut into page ranges before they are read, with each page's images pruned down to the ones it actually draws. Without that, five pages of a 300-page scan once came out at 324 MB. Scanned and handwritten pages are read directly by the model's vision rather than by OCR.

Everything the agent extracts carries a receipt. A summary attaches `(p. N)` to every fact, an extracted row carries a locator back to its source, and every appendix line cites the file and page it came from. The same citations go into a provenance sheet and a review copy with the sources shown in grey, so a reviewer can check any line against its page.

#### Gates

I didn't want correctness to depend on the agent remembering its instructions. Every upload is hashed into a manifest the agent can't modify. After an indexing turn the platform diffs the manifest against the agent's index and posts `[Automatic index check — round N of 5]` until nothing is missing. A provenance gate then requires every appendix line to match a stamped record down to the file and page. The checker is one file installed in both the platform and the container, so the agent can run exactly the check that will judge its work.

Batch work fans out to up to ten subagents in one response. Each subagent's output keeps its page citations, and the conductor merges what comes back.

#### Built to break

The brief was that an agent stopping with nothing able to bring it back had to become impossible. An out-of-memory kill takes down one case and never the server, every way a turn can stop has a bounded automatic recovery, and the user always has a way forward. A chaos suite tests this against the real agent image.

| Fault injected | Must end as |
|---|---|
| Model hangs | stall detected → abort → continue → reply |
| Container killed mid-tool | marked crashed, history intact, Continue works |
| Platform and agent killed together | exactly one automatic resume |
| 300 MB attachment seeded into history | repaired before boot, history under 2 MB |
| Network cut for 15 s | no false "finished" |

All fifteen scenarios pass on the current release, alongside 550 platform tests and about 200 web tests. One bug they caught: compaction logged success 79 times without ever running, because a missing route answered with a `200` and an HTML page.

The same engagement also shipped a document tool suite and a deep-research service built on my own **Hyperresearch** engine. The whole engagement is about 105k lines and 298 commits since March.

### 11 · Concordance

*Legacy Modernization · 2026 · Client work*

**Turns old code into a spec that cites every line.**

A legacy-modernization platform that reads decades-old systems and writes the specification for rebuilding them. Grammar-based parsers establish what the code literally says, a fleet of AI agents proposes the business rules, and each rule must cite a source line the parser has seen or it is rejected. The finished spec passes eight gates, one of them the client approver’s signature, before it is handed to the build platform.

**Skills:** Legacy modernization, COBOL/JCL analysis, Grammar-based parsing, Static analysis, Dependency graphs, Agent fleet orchestration, Citation verification, Business-rule extraction, Spec generation, Reproducible builds, Human-in-the-loop gates, Differential testing

**Tech:** Python, FastAPI, MongoDB, React, TypeScript, Playwright

Write-up: https://jordangibbs.xyz/projects/concordance.md · In the 3D room: https://jordangibbs.xyz/#/concordance

#### Highlights

- Turns decades-old source code into a rebuild spec in which every business rule cites the line it came from
- Real parsers establish the facts, while the AI proposes rules that a referee checks against those facts
- The same source always produces the same spec, down to the byte
- Eight gates, including one signature, stand between the spec and the rebuild

*Client work under NDA. It runs against systems that are still in production, so names and identifying figures are left out; the architecture is described in full.*

#### What it is

Somewhere a program written before most of its users were born still decides how a bill rounds and when a claim gets denied. The people who wrote it have retired and the documentation is a generation out of date, so **the rules only exist in the code.** Writing the replacement is the easier half. The harder half is proving the new system does exactly what the old one did, and pointing an LLM at the codebase only produces a confident summary with a few rules that were never there.

Concordance takes a frozen snapshot of an old codebase in COBOL/JCL, PHP or other legacy languages and produces a build specification covering every business rule, schema, workflow, anomaly, dead-code finding and security finding. Each rule is cited to its exact line and carries a boundary test. That spec is what the client's approver signs and what the build platform rebuilds from.

I led the build from an empty repo to a working platform in about twelve weeks and 681 commits: roughly 125k lines of Python behind a 48-screen operator UI, 82 artifact schemas and 746 passing tests.

#### Parsers for facts, AI for claims

Grammar-based parsers in plain Python read what is literally on each line: symbols, call edges, dead code, schemas, and decimal and rounding semantics. That is ground truth. Headless coding agents read what the code means and propose business rules in plain English, each with a `path:line` citation. That is only a claim. A referee reconciles every claim against the parser.

```
AI claim   RULE: tax = base × rate, truncated to the cent   cites → BILLING.cbl:412
parser     line 412 is a COMPUTE in paragraph 1200-CALC-TAX ✓ ACCEPTED

AI claim   RULE: late fee waived for loyal accounts         cites → BILLING.cbl:999
parser     no such line                                      ✕ REJECTED at the citation gate
```

The model can still be wrong, but a program catches it, so correctness doesn't depend on a reviewer staying alert. Each program is read with a neighbourhood taken from the dependency graph, meaning its includes in full and the programs it calls as interfaces, which is roughly the set of tabs a maintainer would have open. A rule that won't reconcile is flagged and explained, and never quietly dropped.

Every rule carries the formula, its decimal type and scale, the rounding mode, the surrounding control flow and a boundary test placed where truncating and rounding would disagree, so a rebuild that quietly "cleans up" the maths fails at once.

#### Reproducible, gated and tested

Only parser-backed facts go into the spec's hash, so generating it twice from the same source gives an identical `content_sha`. Anything a model touched sits outside the hash, and languages without a real parser go into a labelled advisory lane.

| | Gate | Cleared by |
|---|---|---|
| G0 | Source frozen and sha256-pinned | machine |
| G1 | 100% indexed, with a random sample re-verified | machine |
| G2–G4 | Dead code, citations and boundary tests reviewed | **human** |
| G5 | Spec ready, with no blocking questions left | machine |
| G6 | **The client's named approver signs that the spec is faithful** | **the signature** |
| G7 | Handoff to the build platform | **human** |

After the rebuild, the old and new systems run on the same engineered inputs, aimed at thresholds and half-cent fractions, and their outputs are diffed byte for byte. A divergence names the rule and source paragraph it broke.

The tool is tested on 18 synthetic legacy systems with planted findings, such as dead code, contradictory rules and files written to break parsers, and every planted finding has to surface. A nightly lane runs the real model for about $0.20 a night, with a sabotage mode that proves the lane can go red.

Concordance hands its spec to **Government Coding Agent** at G7. Concordance reads the old system, and Government Coding Agent builds the new one.

### 12 · Government Coding Agent

*Agent Pipeline · 2026 · Client work*

**An agent pipeline from spec to deployed software.**

An AI software factory that interviews you, writes the spec, plans the work, runs a fleet of coding agents in parallel lanes, checks the plan with six validators, audits what the agents ship and deploys it to production. The core platform alone is 882 commits.

**Skills:** Spec-driven development, Requirements interviewing, Agent fleet orchestration, Parallel agent lanes, Container isolation, Plan validation, Automated code audit, Remediation workflows, Infrastructure from spec, Kubernetes deployment, Compliance evidence, Change-request pipelines

**Tech:** Python, FastAPI, MongoDB, React, Docker, Kubernetes, Helm

Write-up: https://jordangibbs.xyz/projects/stealth-agent.md · In the 3D room: https://jordangibbs.xyz/#/stealth-agent

#### Highlights

- An AI software factory: a person describes an app, and the platform interviews them, writes the spec, designs the infrastructure, builds the code with a fleet of agents, audits it and deploys it to Kubernetes
- Parallel coding agents in their own containers, checked by six validators and a separate audit team
- 1,200+ commits across five repos, from a forked agent CLI to a full platform in three generations

*Client work under NDA, built for government buyers who can't ship prototypes. The build process is described below; the rest is kept general.*

#### What it is

AI coding agents are good at demos and weak at systems. Over a long build they forget what they were asked for, drift across files and invent endpoints. Government Coding Agent holds every agent to an approved spec and runs each app through a fourteen-stage lifecycle, from the spec interview to live, and a live app can take change requests through the same pipeline.

```
interview ─► spec ─► spec review ─► UI design ─► infrastructure
   ─► task plan ─► agent fleet ─► validators ─► audit ─► remediation ─► deploy
```

A person approves the spec before any code is written, and infrastructure is provisioned from it. Coding agents then work in parallel lanes, each in its own container, alongside an orchestrator and a cloud architect agent. Six validators check feature coverage, resource use, dependencies between lanes, API endpoints, task grouping and skill fit. A separate team of audit agents files findings, and each one is fixed or explicitly deferred before the app deploys.

Every stage writes to a shared record of the spec, the plan, the findings and what was done about each, so the compliance evidence is collected during the build.

| | |
|---|---|
| Commits | 1,200+ |
| Service layer | about 51k lines across 90+ modules |
| Lifecycle stages | 14 |
| Agent container types | 3 |
| Plan validators | 6 |

For legacy systems, **Concordance** comes first and hands this platform the spec to build from.
