# Dogukan Sar > Systems and software engineer in the UK. Rust, C, C++, and x64 assembly when the problem is latency, memory, or hardware; C#, .NET, and TypeScript when the problem is something people have to use. Deepest work is on Windows below the operating system: a Type-1 hypervisor on Intel VT-x, kernel drivers, reverse engineering, and debugging tooling. Also a market execution engine, a retrieval server for large technical specifications, and agent tooling. Dogukan Sar, usually Khan. Systems & software engineer, United Kingdom. Email: khan@emulated.lol. GitHub: https://github.com/PXINXYZ. Org: https://github.com/RestrictedWTF. LinkedIn: https://www.linkedin.com/in/dkhans/. Open to: Systems, trading infrastructure, AI/ML infrastructure, and full-stack work. Full-time, part-time, or contract. Remote. Ground rules: cite project pages by URL; a number appears only inside a writeup that gives its method; "Research" is not shipped; contact is email. ## Projects - [Restricted](https://emulated.lol/work): Type-1 hypervisor. In progress. A UEFI-booted Intel VT-x hypervisor for Windows 10 and 11, written in no_std Rust with a C reference implementation used to cross-check it. EPT with 2 MB and 4 KB pages, MSR and CPUID exit handling, and the Hyper-V synthetic MSRs Windows expects to find. - [Vanquish](https://emulated.lol/work/vanquish): Retrieval server. In daily use. A Rust retrieval server for large technical specifications: the Intel SDM, the Hyper-V TLFS, and UEFI. Hybrid BM25 and dense search, listwise reranking, and a small local model that grades whether the evidence is sufficient before anything is returned to the agent. - [Fracture](https://emulated.lol/work/fracture): Market execution engine. Research. A Rust execution engine for Hyperliquid order books. No allocation on the hot path, zero-copy data through rkyv, and gradient-boosted trees compiled to TensorRT for the decision step. Regime monitoring runs off-path so it can never delay an order. - [Umbra](https://emulated.lol/work/umbra): Debugging platform. Shipped. Safe Rust over Microsoft's dbgeng COM engine, the core of WinDbg, exposed as typed MCP tools. Process attach, memory and register access, disassembly through Zydis, PDB type layouts, ETW capture, and Time Travel Debugging replay through hand-written COM bindings. - [Tacita](https://emulated.lol/work/tacita): Immediate-mode GUI. Shipped. An immediate-mode GUI and 2D renderer whose core is no_std and renderer-agnostic, for hosts that own their own device and swap chain. Analytic anti-aliasing, no heap allocation once warm, and pixel-exact headless tests on D3D11 and D3D12. - [hyper-v-mcp-rs](https://emulated.lol/work/hyper-v-mcp-rs): Hyper-V control plane. Shipped. An MCP server that exposes the full Hyper-V PowerShell module as typed tools and read-only resources, with a supervised PowerShell sidecar underneath. Guest commands and file transfer run over VMBus through PowerShell Direct, so a VM never needs a network path. - [Transcend](https://emulated.lol/work/transcend): CLI layer for agents. Shipped. Turns terminal output into typed JSON so coding agents work with structure instead of parsing text. Tools chain in-process, so intermediate output never reaches the context window. - [Chiron](https://emulated.lol/work/chiron): Dataset synthesis. Research. A dataset factory that treats frontier models as teachers rather than oracles: panel-based synthesis, judge fusion, and student models promoted to teacher once they pass the evals. ## Experience - Verdict, Founder, 2025 – now: An independent label for my research and systems work. Vanquish, Fracture, Transcend, and Chiron are published under it, each with a writeup that shows the measurements behind any claim. - Turing, Outlier, Model evaluator, contract, 2024 – now: Adversarial evaluation of code-generation models on systems tracks: C and C++ memory safety, concurrency, undefined behaviour, and whether tool calls do what the model says they do. - Independent, Systems engineer, contract, 2023 – now: Windows kernel drivers, hypervisor prototypes, Rust infrastructure, and program-analysis tooling for clients who need something that does not exist yet. ## Credentials - [Azure AI Engineer Associate, AI-102](https://learn.microsoft.com/en-us/credentials/certifications/azure-ai-engineer/), Microsoft - [Certified AI Practitioner, AIF-C01](https://aws.amazon.com/certification/certified-ai-practitioner/), AWS - [Generative AI and LLMs Associate, NCA-GENL](https://www.nvidia.com/en-us/learn/certification/generative-ai-llm-associate/), NVIDIA - [PyTorch Certified Associate, PTCA](https://training.linuxfoundation.org/certification/pytorch-certified-associate-ptca/), Linux Foundation - [Fundamentals of Deep Learning](https://learn.nvidia.com/courses/course-detail?course_id=course-v1:DLI+S-RX-02+V2), NVIDIA Deep Learning Institute - [C++ Certified Associate Programmer, CPA](https://cppinstitute.org/cpa-c-certified-associate-programmer-certification), C++ Institute - [AI Engineering Professional Certificate](https://www.coursera.org/professional-certificates/ai-engineer), IBM - [Applied AI Professional Certificate](https://www.coursera.org/professional-certificates/applied-artifical-intelligence-ibm-watson-ai), IBM - [AI Professional Certificate](https://www.coursera.org/professional-certificates/google-ai), Google - [Data Analytics Professional Certificate](https://www.coursera.org/professional-certificates/google-data-analytics), Google - [IT Support Professional Certificate](https://www.coursera.org/professional-certificates/google-it-support), Google - [Computer Architecture: Assembly Language](https://www.codecademy.com/learn), Codecademy ## Optional - [Full text of every project page](https://emulated.lol/llms-full.txt) - [Structured data](https://emulated.lol/agents.json) - [For agents, in prose](https://emulated.lol/agents) --- # Vanquish URL: https://emulated.lol/work/vanquish Kind: Retrieval server. Status: In daily use. Stack: Rust, llama.cpp, Tantivy, Qdrant, MCP. Subtitle: A neuro-symbolic corrective-retrieval runtime that treats context as infrastructure. Summary: A Rust retrieval server for large technical specifications: the Intel SDM, the Hyper-V TLFS, and UEFI. Hybrid BM25 and dense search, listwise reranking, and a small local model that grades whether the evidence is sufficient before anything is returned to the agent. ## Retrieval is a correctness problem, not a search problem Every coding agent has the same failure mode: it answers from the wrong paragraph with total confidence. The fix is not a bigger context window — it is making sure the model is *looking at the right paragraph, with a citation, and that something checks its work before the answer is written*. Vanquish is that something. Vanquish is a Rust-native, GPU-accelerated **corrective retrieval-augmented generation (CRAG) runtime** exposed as an [MCP](https://modelcontextprotocol.io/) server. It is deliberately *not* an answer generator. It sits between the agent and the corpus, and its only job is to return a graded, line-cited context envelope — `grounded` when the evidence is sufficient, `insufficient` with best-effort leads when it isn't. The calling agent writes the answer; Vanquish decides whether the agent had any business writing it. It currently grounds three corpora I actually work against daily: the Intel 64/IA-32 Software Developer's Manual (~15k structurally-chunked sections), the Hyper-V Top-Level Functional Specification, and the UEFI 2.10 specification. ## The route One core loop, `vanquish_route`, with a model-free fast path and a full corrective path: ```text query → lookup-shaped? → entity-lane / section-ref bypass (~80ms, no models) → otherwise: F2LLM-v2 embed (ONNX) → Qdrant dense + Tantivy BM25 (+ optional codebase graph, capped & gated) → RRF fusion → jina-reranker-v3 listwise rerank (one forward pass, all candidates) → relative-threshold triage → auto-merge: co-located chunks collapse into whole-section spans → grader (Qwen3.5-0.8B, logit-confidence): sufficient? yes → envelope { status: grounded } no → per-chunk CRAG refinement, prune noise → widen: hint-augmented query + entity-anchored traversal along parsed cross-references, relaxed triage → loop (bounded; early exit when nothing new surfaces) exhausted → envelope { status: insufficient, best-effort leads } ``` Three design choices carry most of the weight: **Structure-aware ingestion.** Documents are chunked by heading hierarchy, every chunk prefixed with its breadcrumb. Tables and code fences stay atomic — a half-table is worse than no table. Cross-references ("see Section 28.2.3") are parsed at ingest into a traversable graph, which is what makes the *widen* step symbolic rather than another blind embedding call: when the grader rejects a pass, Vanquish walks the document's own citation structure. That is the "neuro-symbolic" in the tagline — neural retrieval, symbolic correction. **A grader that reads logits, not vibes.** The sufficiency judge is Qwen3.5-0.8B running under [llama.cpp](https://github.com/ggml-org/llama.cpp) GGUF, and its verdict is the first-token probability of the positive class — a calibrated logit-confidence read, not parsed free text. Bounded loops (3 max) with early exit keep worst-case latency sane. **A tool family, not one endpoint.** `vanquish_outline` (TOC from breadcrumbs — navigate before querying), `vanquish_lookup` (exact-match entity lane for registers, MSRs, opcodes), `vanquish_expand` (fetch exact lines from a citation), `vanquish_overview` (RAPTOR-lite cached section summaries), `vanquish_status`, and `vanquish_feedback` — a usefulness signal that is the data source for future tuning. Cited spans are also readable as MCP resources (`vanquish://source#L1042-L1069`), so the client never needs filesystem access. ## The model stack is pinned by measurement | Role | Model | Backend | |---|---|---| | Embedder | F2LLM-v2-0.6B | ONNX | | Reranker | jina-reranker-v3 (BF16) | listwise, llama.cpp GGUF + safetensors projector | | Grader | Qwen3.5-0.8B (UD-Q5_K_XL) | llama.cpp GGUF, ChatML, logit-confidence | None of these are defaults — each won a measured bake-off against its alternatives, and a `shadow_reranker_backend` config can A/B a challenger against live traffic (logging rank disagreements and Kendall tau) without touching served results. Storage is [Qdrant](https://qdrant.tech/) for dense vectors, [Tantivy](https://github.com/quickwit-oss/tantivy) for BM25, and SQLite for sections, entities, cross-references, feedback, and shadow-rerank disagreements. The retrieval plane is load-tested at 13M+ vectors — the corpora above are small by design (precision beats bulk for spec work), but the pipeline does not break a sweat at eight figures. ## Evals are the gate, not an afterthought `vanquish-eval` ships a golden set of hand-authored SDM queries with expected sections and fragments — grep-verified against the real corpus, CPU-only, CI-run — plus deterministic route-trace replay so any change can be regression-checked against recorded history, and `compare` to diff two runs. The rule is simple: nothing model-shaped — reranker swap, grader swap, HyDE, multi-query, merge policy — ships as the default until the harness says so with a number. For concurrency, the server also runs as an HTTP daemon: one warm process serving N agents behind mandatory bearer auth, with per-session cancellation and an admission semaphore — so a fleet of agents doesn't each pay for its own ~3GB of loaded models. ## What I actually use it for The corpus set is the tell: Intel SDM, Hyper-V TLFS, UEFI. Vanquish exists because hypervisor work means living inside three specifications totalling tens of thousands of pages, and "the agent hallucinated a VMCS field encoding" is a multi-day debugging sentence. Grounded retrieval with line citations turns spec consultation from a liability into a fast path — and the same runtime grounds anything else I point the indexer at. --- # Fracture URL: https://emulated.lol/work/fracture Kind: Market execution engine. Status: Research. Stack: Rust, rkyv, SIMD, TensorRT. Subtitle: A zero-copy Rust execution engine with a one-step flow Q-learning policy. Summary: A Rust execution engine for Hyperliquid order books. No allocation on the hot path, zero-copy data through rkyv, and gradient-boosted trees compiled to TensorRT for the decision step. Regime monitoring runs off-path so it can never delay an order. ## Determinism first Fracture is a zero-copy Rust crypto trading engine built for absolute execution determinism on AWS colocation nodes. Every architectural decision answers to one metric: hot-path determinism under 10ms p95 with jitter under 50µs — because in this domain, variance *is* the bug. Exchange priority is Hyperliquid (primary — the hardened deterministic execution path), with MEXC scaffolded. Training data is dollar bars from Binance; live signal is the Hyperliquid L2 order book. ## The hot path The engine operates entirely within the colocation perimeter — no internet-bound sidecars adding network jitter. WebSocket streams feed a wait-free SPSC ring buffer, and the hot-path thread processes market events without mutex contention: 1. **Ingestion** — raw NIC packets, [rkyv](https://github.com/rkyv/rkyv) zero-copy cast straight to structs at memory speed 2. **Feature compute** — SIMD-accelerated, 64-dim vector, zero-alloc 3. **Signal** — Hummingbird-compiled GBDT, FP16 TensorRT 4. **Policy** — OFQL, one deterministic forward pass 5. **Sentinel** — Qwen3.5-0.8B (INT8), logit-space risk scaling 6. **Gate** — stack-only risk veto engine 7. **Execution** — `OrderCommand` dispatch **Zero-copy data path.** Serde-style serialize/deserialize creates unacceptable jitter through heap allocation. rkyv lets the hot path cast network buffers directly to Rust structs — deserialization at memcpy cost, nanosecond scale. **Hummingbird GBDT signals.** Transformers scale quadratically on limit order book features. [Hummingbird](https://github.com/microsoft/hummingbird) compiles gradient-boosted decision trees into tensor math that runs directly on TensorRT — frontier-grade alpha generation at sub-microsecond inference latency. The right model for the hardware, not the fashionable one. ## OFQL: one-step flow Q-learning The problem with IQL-style expectile regression in crypto is sensitivity to extreme variance — token unlocks, cascade liquidations, the kind of multi-modal reward landscape that breaks single-distribution assumptions. Iterative approaches (diffusion policies, multi-step integration) buy expressiveness with latency the hot path can't afford. OFQL — One-Step Flow Q-Learning — models that multi-modal landscape *deterministically in a single forward pass*, collapsing probability mass onto optimal trajectories without iterative denoising. Sampling is event-driven: volume-weighted dollar bars (in the [López de Prado](https://www.wiley.com/en-us/Advances+in+Financial+Machine+Learning-p-9781119482086) sense) instead of time bars — signal over noise, with decision triggers on threshold crossings. ## The risk sentinel The policy never reaches the exchange ungated. A Qwen3.5-0.8B sentinel — small enough to run INT8 on the same GPU without disturbing the hot path — reads the state and emits a **logit-space risk scalar**: not a chat completion, not parsed text, a calibrated number read straight off the output distribution. The veto engine is stack-only, fully deterministic, and the action vector is gated by that scalar before any order dispatches. A hardcoded `DETERMINISTIC_NOISE` tensor keeps policy inference reproducible across runs — replayability is a hard requirement for post-trade forensics. ## Performance targets | Metric | Target | Status | |---|---|---| | Hot-path determinism | < 10 ms p95, < 50 µs jitter | Validated | | Serialization | Zero-copy (rkyv) | Validated | | Feature compute | SIMD, 64-dim, zero-alloc | Validated | | Signal inference | FP16 TensorRT (Hummingbird GBDT) | Validated | | OFQL policy | One-step forward pass | Open | | Sentinel | Qwen3.5-0.8B INT8, logit-space | Open | Inference is compiled per colocation hardware target — the same FP16 engine runs 0.82ms on an RTX 5090 tier, 3.1ms on a 4090, 9.2ms on a 4080 Mobile. The engine knows its hardware budget the way the risk gate knows its scalar: measured, pinned, and enforced. --- # Umbra URL: https://emulated.lol/work/umbra Kind: Debugging platform. Status: Shipped. Stack: Rust, dbgeng, COM, Zydis, ETW, MCP. Subtitle: Windows debugging as typed objects, with an MCP front end. Summary: Safe Rust over Microsoft's dbgeng COM engine, the core of WinDbg, exposed as typed MCP tools. Process attach, memory and register access, disassembly through Zydis, PDB type layouts, ETW capture, and Time Travel Debugging replay through hand-written COM bindings. ## The problem Every debugger speaks to humans in console text. That is fine at a keyboard and useless for anything programmatic: a script, an IDE plugin, or an agent has to scrape output that was formatted for eyes, and every change to the formatting breaks the scraper. Windows makes this worse because the capable engine, `dbgeng`, is a COM surface that few languages wrap safely. Umbra is a Rust server that wraps `dbgeng` and exposes debugging as structured, typed objects over the Model Context Protocol. Addresses are hex strings, registers are decoded integers, stack frames carry resolved symbols, and every response has a schema. The same backend serves a CLI, a GUI, a REST layer, or an agent, because none of them ever see console text. ## Architecture Four layers, each a crate boundary: - **`umbra`**, the MCP server binary. Session manager, TTD manager, tool router, JSON serialisation. Speaks JSON-RPC over stdio. - **`debugger`**, the orchestrator. Attach and detach, break, step, memory and registers, stack, modules, symbols, kernel driver and handle enumeration. - **`dbgeng`**, safe wrappers over the COM interfaces: `IDebugClient`, `IDebugControl`, `IDebugSymbols3`, `IDebugDataSpaces`, `IDebugRegisters`, `IDebugSystemObjects`. - **`dbgeng.dll`** itself, reaching a live process, a dump file, a kernel target, or a remote. Around those sit `disassembler` (Zydis, x86 and x64), `symbols` (offline PDB type resolution through the `pdb` crate, so a type layout such as `nt!_EPROCESS` can be resolved without a live session), `etw` (real-time Event Tracing for Windows through `ferrisetw`), `extensions` (extension output capture and gated command invocation), and `ttd` (Time Travel Debugging replay through Microsoft's ReplayApi FFI). ## The tool surface Attach to a process, dump, or kernel target and get a session. From there: break, resume, single-step, read and write memory, get registers, walk the stack with symbols, list modules, processes, and threads, resolve a symbol to an address, resolve a type's layout with field offsets, disassemble at an address, set and list breakpoints with pass counts, and poll for debugger events. Multiple sessions run side by side. ## Security The free-form command path reaches `IDebugControl::Execute`, which can run anything the debugger can. Because agents can reach the tool surface, that path is treated as a security boundary rather than a convenience. Every command is validated in two stages: 1. **Structural rejection** of the characters that enable chaining, nesting, scripting, and redirection: semicolons, pipes, angle brackets, braces, quotes, backticks, and newlines. This alone defeats `.shell` tricks, script sourcing, and output redirection. 2. **A default-deny allowlist** for dot-commands, where every host-affecting verb lives, plus rejection of the `!!` shell alias and of alias-definition verbs, since `dbgeng` expands aliases at execution time. Host code execution, process spawning, file writes, and script sourcing are denied. Read-only inspection and debuggee-scoped commands remain available. Loading extension DLLs is not exposed to agents at all, since a DLL's entry point is arbitrary native code. ## Known limitations - Disassembly is x86 and x64 only. ARM64 targets are rejected before decode. - Float and vector registers come back as raw little-endian bytes; integer registers are decoded. - The event channel is best-effort. Breakpoint and exception notifications share a bounded channel with module-load events, and a burst of DLL loads at startup can drop events. Execution status remains the ground truth for stops. - ETW is system-global. One real-time trace can run at a time; a session's trace is stopped when the session is destroyed and force-stopped at process exit so nothing is orphaned. - Kernel driver and handle enumeration still needs validation against a live kernel target. - TTD replay is experimental and has not been verified against a live trace. ## Status Shipped and in use. The `dbgeng` wrappers, the orchestrator, disassembly, symbols, ETW, and the MCP server are complete. TTD and the kernel walks are the open edges. --- # Tacita URL: https://emulated.lol/work/tacita Kind: Immediate-mode GUI. Status: Shipped. Stack: Rust, no_std, D3D11, D3D12, wgpu, C++ FFI. Subtitle: An immediate-mode GUI whose core has no operating system and no GPU in it. Summary: An immediate-mode GUI and 2D renderer whose core is no_std and renderer-agnostic, for hosts that own their own device and swap chain. Analytic anti-aliasing, no heap allocation once warm, and pixel-exact headless tests on D3D11 and D3D12. ## The problem Most GUI libraries assume they own the window, the device, and the frame. Embed one inside a host that already owns all three, such as a tool drawing through a host application's swap chain, or a target with no operating system at all, and the assumptions fight you at every step. Tacita's core is `#![no_std]`, built on `core` and `alloc` with no C runtime, and it never touches a GPU or an OS API. The host feeds it a snapshot of input each frame, declares the interface with flat calls, and takes back vertex, index, and command lists to draw with whatever renderer it brought. ## Architecture The host's input layer translates raw events into a per-frame `InputState`. The `adapters/win32` crate does this for Win32 messages without any `unsafe` and without calling into Win32 itself. The core consumes that state, runs widgets, layout, ID management, capture and z-order, rasterises text and shapes into coverage masks, and emits `DrawData`. Backends for D3D11 and D3D12 turn `DrawData` into draw calls against a device and swap chain the host owns; a `wgpu` harness is the reference backend for development. Two more entry surfaces sit beside the core: a flat `Gui` facade in `sdk`, and an `extern "C"` layer in `ffi` with a hand-written C++ header. A two-sided consistency guard keeps the header and the Rust structs in lockstep, so a layout change on either side fails the build rather than corrupting memory at runtime. ## Widgets and rendering Windows, tabs, collapsing headers, scroll regions, checkboxes, sliders, buttons, text inputs, combo boxes, an HSV colour picker, keybind selectors, tooltips, and icon fonts merged into the same atlas as text. Anti-aliasing is analytic: exact pixel coverage in the AGG and FreeType lineage, rasterised once and cached as masks in the font atlas. After warm-up, a steady-state frame allocates nothing. ## Verification - More than 400 core tests covering widget logic, capture and z-order semantics, layout, and the zero-allocation guarantee, which is enforced by a counting allocator rather than assumed. - Headless GPU tests on real hardware for both D3D11 and D3D12. Frames are rendered, read back, and asserted pixel-exact. - An MSVC-compiled C++ consumer exercising the FFI surface. - The `no_std` gate: the core builds for `x86_64-unknown-none`. ## Status Feature-complete and in use: the full widget set, both native backends, the C++ FFI, and the Win32 adapter are shipped and verified. The API surface may still shift. IME and CJK input and multi-viewport support are on the list, pulled by real use rather than a roadmap. --- # hyper-v-mcp-rs URL: https://emulated.lol/work/hyper-v-mcp-rs Kind: Hyper-V control plane. Status: Shipped. Stack: Rust, rmcp, tokio, Hyper-V, PowerShell Direct, DPAPI. Subtitle: The whole Hyper-V PowerShell module as typed tools, plus guest control with no network. Summary: An MCP server that exposes the full Hyper-V PowerShell module as typed tools and read-only resources, with a supervised PowerShell sidecar underneath. Guest commands and file transfer run over VMBus through PowerShell Direct, so a VM never needs a network path. ## The problem Hyper-V is driven through a PowerShell module with hundreds of cmdlets. Anything that wants to automate it, a test harness, a lab controller, an agent, ends up shelling out and parsing text. The cmdlets also need an elevated, persistent PowerShell process, which is exactly the kind of thing that hangs, dies, or leaks. hyper-v-mcp-rs puts a Rust process in front. Every cmdlet in the module is exposed as a typed MCP tool, named `hyperv__`, with input and output schemas derived from Rust structs and surfaced to the host as JSON Schema. Inventory, network topology, and host information are read-only resources. ## Architecture The binary runs on `tokio` with a hand-written `rmcp` server handler and a tool registry collected at link time. Beneath it is a PowerShell sidecar, embedded into the binary with `include_str!` so nothing is written to disk. On first use the sidecar checks that it is elevated, reports ready, and then runs a persistent runspace loop, executing cmdlets and returning JSON. The Rust side supervises the sidecar. If it crashes, hangs, or exceeds the per-call timeout, it is killed and restarted, and any pending calls fail with a structured error rather than a stuck process. Transport is stdio only: JSON-RPC in from the host, JSON-RPC out to the child. ## Guest control PowerShell Direct runs commands and moves files inside a running VM over VMBus, with no network connectivity required. Credentials resolve in a fixed order: explicit username and password in the call, a VM-specific entry in a DPAPI-encrypted store, a default credential from the config file, and otherwise an error naming the tool that registers one. The default is meant for a known base image with a fixed local administrator, from which agent-created VMs derive. ## Requirements Windows with Hyper-V enabled, administrative privileges (the server exits if it is not elevated), and PowerShell 5.1 or later. ## Status Shipped. The tool surface tracks the Hyper-V module cmdlet for cmdlet. --- # Transcend URL: https://emulated.lol/work/transcend Kind: CLI layer for agents. Status: Shipped. Stack: Node.js, MCP, JSON-RPC, Nunjucks. Subtitle: An agent-native CLI layer that turns terminal output into typed contracts. Summary: Turns terminal output into typed JSON so coding agents work with structure instead of parsing text. Tools chain in-process, so intermediate output never reaches the context window. ## The context tax Every AI coding agent runs the same broken loop: 1. Call a CLI tool (`grep`, `find`, `cat`) 2. Receive kilobytes of human-formatted terminal output 3. Dump it into the context window 4. Parse it with the LLM — the world's most expensive regex engine 5. Repeat This works on toy projects. On real codebases it physically cannot work. A single [ripgrep](https://github.com/BurntSushi/ripgrep) across a large repository can return tens of thousands of matches, and the standard agent workflow turns that into millions of tokens. No model on Earth has a context window that large — and even if it did, you'd be paying frontier prices to do string parsing. Transcend makes it trivial: **terminal text in, typed JSON contracts out**, with 89–93% context reduction and reasoning payloads under 12KB across 24,000+ matches. ## "But tools already have `--json` flags" Some do. Most don't. And even when they do, JSON output is not the same as a typed contract. `rg --json` emits NDJSON with envelope messages, redundant path repetition per match, nested stat objects, and begin/end wrappers that carry zero information for the agent. Multiply by 24,000 matches and you have megabytes of verbose, tool-specific JSON. Three gaps that `--json` flags don't close: **No normalisation.** Every tool has a different schema. `rg --json` looks nothing like `fd --json`. Transcend normalises all of them into one universal output contract — same shape, every tool, every time. **No chaining without a context-window relay.** Even with JSON output, the agent reads results into its context, extracts file paths, then generates the next call. Transcend chains skills *in-process*. The agent says "search, then replace" once; the intermediate file list never enters the context window. **No cross-tool contract.** Raw tool JSON means N different schemas and arbitrary fallback behaviour when a binary isn't installed. Transcend skills declare their fallbacks, and every fallback normalises to the same schema regardless of which binary actually executed. ## Skill contracts A Transcend skill is a `.skill.json` file: typed inputs, typed outputs, an execution template, and a normalisation pipeline. Every field is a contract — the agent knows what goes in, what comes out, what can chain next, and what happens if the tool isn't installed. No guessing, no parsing. Execution compiles the template through a fast [Nunjucks](https://mozilla.github.io/nunjucks/) engine and pipes directly to native Rust/Go binaries — ripgrep, fd, ast-grep, jq, yq, sd, delta, hyperfine, scc. The wrapper tax is a myth: emitting `rg --json` is computationally *cheaper* than formatting human-readable text, and the warm MCP runtime makes Transcend faster than raw interactive `rg` in practice. 29 typed skills across 9 categories — search, text/data, git, dev, view/sys — 285 tests across 85 suites. ## MCP integration Transcend exposes its skills through the [Model Context Protocol](https://modelcontextprotocol.io/) over stdio, so it's instantly compatible with any MCP host — Claude Code, Cursor, Zed, Windsurf, and anything else that speaks the protocol. Discovery is `tools/list`, execution is `tools/call` with JSON arguments, and the return is always `{"status":"ok","data":…}` with exact byte offsets, line numbers, and checksums. Zero install: ```bash npx -y github:PXINXYZ/Transcend --mcp ``` ## Why agents reason better here Agents reason over structured data, not terminal text. Tool pipelining passes data between tools internally and returns only a summary manifest — no context-window relay, no OS command-line length limits, no heuristic path-parsing failures. The LLM stops being a regex engine and goes back to being a reasoning engine, which is what you're paying for. Source: [github.com/PXINXYZ/Transcend](https://github.com/PXINXYZ/Transcend). --- # Chiron URL: https://emulated.lol/work/chiron Kind: Dataset synthesis. Status: Research. Stack: Teacher panels, Judge fusion, Evals. Subtitle: Recursive self-improvement through teacher-model dataset synthesis. Summary: A dataset factory that treats frontier models as teachers rather than oracles: panel-based synthesis, judge fusion, and student models promoted to teacher once they pass the evals. ## From inference to synthesis Most systems ask: how do we get a better answer? Chiron asks: how do we get better *training data*? Chiron is not a chatbot. It is a dataset factory that treats frontier models as teachers, not oracles. Every task is routed through a pedagogical runtime that forces the teacher to externalize its reasoning in four structured containers — ``, ``, ``, `` — as specified in the TEACHER.md protocol. The output is not a single answer. It is a fully traceable reasoning graph: capability checks, rejected alternatives, tool calls, citations. That graph becomes a training example. The goal is recursive self-improvement — use today's best teachers to create tomorrow's better student, then promote that student to teacher. ## Why containers beat completions Raw distillation — "ask a big model, train on its answer" — inherits every shortcut the teacher took. The reasoning that makes an answer *correct* never touches the page, so the student learns the shape of confidence without the substance of verification. The TEACHER.md protocol exists to externalize that hidden structure: - `` — a capability check, not a plan: what resources, skills, and tools does this task actually require? Rejected approaches are recorded here, which is what makes them trainable signal instead of invisible bias. - `` — a minimal, verifiable task breakdown. Deliberately *not* forced when the task is simple — synthetic decomposition teaches students to perform process theater. - `` — the real reasoning, with a hard rule against fabricated self-corrections and simulated test failures. A reasoning trace full of fake pivots trains a student that pivots *pointlessly*. - `` — the clean, correct, ready-to-use answer. Just as important is what the protocol forbids: the teacher is never told it is generating training data. Any awareness of the pipeline contaminates the trace with meta-commentary — the reasoning equivalent of acting for the camera. ## The teacher panel Single-teacher synthesis has a ceiling: the teacher's blind spots become the student's blind spots, permanently. Chiron therefore fans raw tasks out to a *panel* of frontier models, and a judge model fuses their responses into three artifacts: **consensus** (high-confidence training signal), **contradictions** (the most valuable examples in the set — this is where the frontier actually is), and **blind spots** (questions every teacher dodged, routed for harder synthesis or human review). ```text RAW_TASK ──► DeepSeek V4 Pro ┐ ──► Kimi K2.6 ├─► JUDGE ──► consensus / contradictions / blind spots ──► Gemini 3 Flash ┘ │ ▼ TEACHER.md containers → DATASET → train student │ └────► student promoted → next teacher ``` Teacher selection is benchmark-driven, not brand-driven. On the DRACO deep research benchmark, the current primary teacher scores at the frontier solo, and the budget panel it anchors beat more expensive solo configurations at roughly half the cost. When a better teacher appears — or a retired one returns — the panel rotates. The pipeline doesn't care whose name is on the weights. ## The recursive loop The student trained on panel-fused, container-structured data becomes the next-generation teacher — and this is where discipline matters, because naive self-training is a well-documented collapse mechanism. Chiron's defenses are structural: 1. **Contradiction examples stay in the set.** Collapse happens when the distribution narrows to what the teacher already finds easy; disagreement regions are exactly what keeps the distribution wide. 2. **The judge is anchored outside the loop.** Panel fusion uses models that are *not* descendants of the current student line, so stylistic drift can't launder itself into ground truth. 3. **Evals gate promotion.** A student is promoted to teacher only on measured improvement on held-out tasks — the same evals-first discipline as everything else I build. ## What it's for The near-term target is specialist students: small, fast models that internalize the operating discipline of much larger teachers for specific domains — systems engineering, agentic coding, research synthesis. The long-term bet is the loop itself: if each generation's student makes a measurably better teacher, dataset quality — not parameter count — becomes the scaling axis you actually control.