Research Blog
Ideas, experiments,
and findings.
Technical articles and accessible explanations from across our five research domains.
Long-form notes from the lab, written in the register we would use in a design review rather than in an announcement. Each article is attached to a repository, states the regime its claim holds in, and names the place where the argument breaks down.
Three kinds of article live here
Comparisons place one of our projects against the alternatives an engineer would genuinely shortlist — DSPy, Mem0, Ollama, LiteLLM, Pinecone, gVisor, Algolia, RAWSim-O, Signal and the rest — and every one of them has to say where the alternative wins. A comparison whose author prevails on every axis is not a comparison, and a reader who has used the other tool stops at the first claim they know to be false.
Architecture notes work through a design decision in detail: why memory and context are different concerns, why a fixed six-step search pipeline is preferable to an agent loop, why a sandbox that keeps most syscalls on the host kernel is the right trade for short-lived executions and the wrong one for long jobs. These are the articles where the interesting content is the reasoning rather than the result.
Method notes are about how the lab operates — publishing negative results, declaring scope boundaries alongside features, and measuring whether answer engines cite us by querying them directly rather than inferring it from analytics that cannot see them.
How to read a claim here
Where a number appears, the procedure that produced it is in the repository the article came from, and a seed or a scenario file will regenerate it. Where we do not have a number, the mechanism is described and the absence is stated rather than papered over with a comparative adjective. Articles that answer their question unfavourably stay published, because a body of work containing only successful experiments is a filtered sample of its own evidence.
Use the category tabs below to enter by research pillar, or start from the five research questions, the multi-part series, or the glossary if the vocabulary is unfamiliar.
Proving Who Sent a Message Without Revealing To Whom
End-to-end encryption hides content but leaks the social graph. How Schnorr proofs over blinded pseudonyms let a recipient verify a sender with no directory.
Measuring Whether Answer Engines Cite You
Analytics cannot see an AI answer. A reproducible method for asking Perplexity, ChatGPT, Claude and Google AI Mode the same questions and recording who they cite.
Reward Design for Warehouse Dispatching Agents
Why throughput is a poor training signal for RMFS dispatching policies, and how a five-bucket decomposition of cycle time gives per-decision credit instead.
compere vs Bradley-Terry: Selection Policy vs Rating Model
compere pairs UCB1 pair selection with Elo ratings. Why that differs from Bradley-Terry and TrueSkill, and when each half of the ranking problem matters.
embedcache vs Redis vs GPTCache: Caching Embeddings
How embedcache (local embedding plus a SQLite cache) compares with a DIY Redis cache and GPTCache's semantic cache, and what each one actually stores.
l0l1 vs Text2SQL Tools: Validating SQL Instead of Writing It
l0l1 is not a Text2SQL tool. It validates SQL of any origin, scans for PII and learns approved query patterns. How it compares with Vanna, SQLCoder and others.
llamafu vs llama.rn: On-Device LLMs for Flutter and React Native
A practical comparison of llamafu, llama.rn and llama_cpp_dart for running llama.cpp models in mobile apps: what each binding covers and how to choose.
memista vs Pinecone vs Qdrant: Do You Need a Vector DB?
memista, Pinecone, Qdrant, Weaviate, Milvus and Chroma compared on architecture, scale and operations, and where an experimental embedded index stops being enough.
mullama vs Ollama vs vLLM: Choosing a Local LLM Server in 2026
Comparing mullama, Ollama, vLLM, LocalAI and LM Studio for local LLM serving: when to use which, and when in-process inference beats a daemon.
perishable vs Cloudflare vs Vault: LLM Keys Out of the Browser
perishable is a self-hosted proxy and browser SDK that keeps LLM API keys off the client. How it compares with Cloudflare's gateways and HashiCorp Vault.
polymathy vs Haystack vs LangChain: Retrieval in Rust
Comparing polymathy with Haystack, LangChain and LlamaIndex: a single-endpoint Rust fetch-and-chunk service against full Python RAG frameworks.
route-switch vs LiteLLM vs Portkey: LLM Gateways in 2026
Comparing route-switch, LiteLLM, Portkey and OpenRouter: what each gateway routes, what it records, and where MIPROv2 prompt optimisation fits in.
savanty vs NL4Opt, Chat LLMs and Hand-Written Solver Models
Where savanty fits: an LLM-to-Clingo pipeline compared with asking a chatbot, NL4Opt-style research systems, and writing an OR-Tools or MiniZinc model yourself.
Skelf Research: The Independent Lab That Ships Research as Code
What an independent lab that ships every hypothesis as a public repository does differently from a corporate AI research group, and where it cannot compete.
slorg vs Algolia vs Meilisearch: Plan-First Search
slorg drafts an answer, builds a knowledge graph and then searches the web. Why that differs from Algolia, Meilisearch and Typesense, and when each wins.
ukkin vs ChatGPT Operator: On-Device vs Cloud Agents
Comparing ukkin with OpenAI's Operator and Anthropic's computer use: a phone-side Android agent against cloud-model agents, on privacy, platform and capability.
waremax: Deterministic Warehouse-Robotics Simulation
How waremax models Kiva-style RMFS warehouses deterministically for reinforcement-learning research, and how it differs from RAWSim-O.
zviz vs gVisor vs Firecracker: Sandboxing AI Code
Deny, emulate or virtualise? How zviz's selective-denial container runtime compares with gVisor, Firecracker and WASM for running untrusted AI code.
memorg vs Mem0: Structured Memory vs Vector Memory for LLM Agents
A practical comparison of memorg and Mem0 for agent memory: an inspectable conversation store versus LLM-extracted facts, and when each one fits.
mpl vs MCP: An Audit and Contract Layer for Agent Protocols
MCP defines how agents talk. mpl checks what they said against a contract, scores it and records it. Why production agent systems may need both.
promptel vs DSPy: Declarative Prompts vs Compilation
Comparing promptel and DSPy: when to use a declarative prompt specification, when to use a programmatic compiler, and how the two compose.
Programmable Databases: Why We Built liath Twice
liath lets agents query their own memory in sandboxed Lua. Why we built it as a Python package, rebuilt it as a Rust crate, and what we would measure next.
Deliberative Search: When the Engine Reasons Before It Retrieves
Traditional search retrieves first and ranks later. slorg inverts the order: a fixed six-step pipeline drafts an answer and a plan before it queries the web.
Persistent Memory for Long-Running Agents
What happens when LLM agents must remember across sessions: memorg's conversation hierarchy, hybrid vector and keyword retrieval, and memory versus context.
Vector Search Without the Cloud: memista, SQLite and HNSW
Why memista pairs SQLite metadata with an in-process USearch HNSW index, what that buys a small retrieval workload, and how to measure whether yours fits.
Ephemeral Credentials and Zero-Trust AI: Rethinking API Security
Why AI clients and agents need short-lived, scoped credentials, what perishable implements today for browser-side LLM access, and what it deliberately does not.
Prompt Lifecycle Management: From Extraction to Deployment
A practical framework for managing prompts as versioned, locked dependencies: extraction with blogus, regression testing, deployment, and catching drift.
Better Rankings, Fewer Comparisons: Bandits for Ordering
How compere ranks items from pairwise votes: UCB1 chooses which pair to compare next and Elo turns each outcome into a rating. Mechanism, limits and uses.
Formalising Prompts as First-Class Research Objects
Why treating prompts as typed, portable artefacts changes how we reason about LLM behaviour, and how promptel and blogus put that idea into practice.
From English to Clingo: Where the Translation Breaks
Why turning English into a solver model is the hard part: where savanty's LLM-to-ASP translation fails, and how typed repair and unsat cores make it visible.
Intelligent LLM Routing: Spending Compute Where It Matters
How route-switch routes LLM traffic by configured strategy, logs every call to DuckDB and SQLite, and reruns MIPROv2 prompt optimisation on captured traces.
Autonomous Mobile Agents: ukkin's Architecture for On-Device AI
How ukkin builds phone-side agents from plain English and drives Android apps through the Accessibility Service, and where on-device autonomy needs limits.
Building mullama: What We Learned Replacing Ollama from Scratch
Why mullama is a Rust runtime on llama.cpp with native bindings for six languages and an Ollama-compatible CLI, and what in-process inference changes.
Running Language Models on Your Phone: The llamafu Experiment
What it takes to run an LLM on a phone with no cloud dependency: the memory arithmetic, quantisation trade-offs, and how llamafu brings llama.cpp to Flutter.
Sandboxing Untrusted Code in Zig: The zviz Architecture
How zviz contains untrusted and AI-generated code by selective denial: namespaces, Landlock, seccomp-BPF and cgroups v2, with policy built at Zig comptime.
Why We Write AI Infrastructure in Rust (and Zig, and Go)
Language choice as research methodology: why we pick Rust, Zig or Go by the confounding variables each removes from the systems claims we intend to test.
Compiling Trading Signals: The sigc Hypothesis Pipeline
How sigc compiles a typed trading-signal DSL to IR, caches results by content hash, and runs one binary from backtest to production daemon, limits included.
Open Science in AI: Why We Publish Everything
The case for openness in AI research: reproducible methods, falsifiable claims, and saying plainly which of our own claims have not yet been measured.