Research Blog
Ideas, experiments,
and findings.
Technical articles and accessible explanations from across our five research domains.
compere: Multi-Armed Bandit Ranking with Fewer Comparisons
How compere uses bandit algorithms to rank items with minimal pairwise comparisons — applications in search evaluation, recommendation, and tournament design, vs Bradley-Terry and TrueSkill.
embedcache vs Redis vs GPTCache: Caching for Embedding Computations
A practical comparison of embedcache, Redis vector cache, and GPTCache for eliminating redundant embedding recomputation in RAG pipelines.
l0l1 vs Text2SQL Tools: A Privacy-Preserving SQL Co-Pilot for Your Own Database
A practical comparison of l0l1 with generic Text2SQL tools — when the privacy guarantee matters, when the learning from query patterns matters, and when a vanilla LLM SQL bridge is enough.
llamafu vs llama.rn vs flutter_llama_cpp: On-Device LLM for Flutter in 2026
A practical comparison of llamafu, llama.rn, and flutter_llama_cpp for running LLMs on Flutter — what each does well, what each doesn't, and which to pick.
memista vs Pinecone vs Qdrant vs Chroma: Do You Need a Vector Database?
A practical comparison of memista, Pinecone, Qdrant, Weaviate, Milvus, and Chroma for vector search — and why the answer is usually 'no, you need SQLite'.
mullama vs Ollama vs vLLM: Choosing a Local LLM Server in 2026
A practical comparison of mullama, Ollama, vLLM, LocalAI, and LM Studio for local LLM serving — when to use which, and why you might pick the research-instrumented option.
perishable vs Cloudflare API Gateway vs HashiCorp Vault: Short-Lived Credentials for LLMs
A practical comparison of perishable, Cloudflare API Gateway, and HashiCorp Vault for ephemeral LLM API credentials — when zero-trust LLM access needs its own purpose-built tooling, and when a general-purpose solution is enough.
polymathy vs Haystack vs LangChain: Building RAG Pipelines in Rust
A practical comparison of polymathy, Haystack, and LangChain for building RAG pipelines — when you want a Rust-native async chunking + embedding service, and when the Python frameworks are still the right answer.
route-switch vs LiteLLM vs Portkey vs OpenRouter: LLM Routing in 2026
A practical comparison of route-switch, LiteLLM, Portkey, and OpenRouter for LLM routing — when you need a gateway, when you need a learned router, and when you need both.
savanty: Bridging Natural Language and Mathematical Solvers in 2026
How savanty turns English problem descriptions into mathematically guaranteed solutions. The case for LLM-to-formal-solver pipelines over pure LLM output.
Skelf Research: The Independent Lab That Ships Research as Code
How Skelf Research compares to Big Tech AI labs, AI startups, and individual researchers — what 'independent AI research lab publishing open-source software' means in 2026, and why the methodology is the moat.
slorg vs Algolia vs Meilisearch vs Typesense: Deliberative vs Traditional Search
A practical comparison of slorg, Algolia, Meilisearch, and Typesense for search — when deliberative search (reasoning before retrieval) is the right answer, and when traditional search is still the right answer.
ukkin vs ChatGPT Operator vs Anthropic Computer Use: On-Device vs Cloud AI Agents
A practical comparison of ukkin, ChatGPT Operator, and Anthropic Computer Use for autonomous mobile and desktop AI agents — privacy, autonomy, and the on-device vs cloud trade-off.
waremax: Deterministic Warehouse-Robotics Simulation for RL Research
How waremax gives warehouse-robotics research a deterministic simulator, a Gymnasium RL interface, and instrumented delay attribution. Why deterministic beats plausible for reproducible research.
zviz vs gVisor vs Firecracker: Choosing a Sandbox for AI-Generated Code
A practical comparison of zviz, gVisor, and Firecracker for sandboxing untrusted AI-generated code — performance, security, and operational trade-offs.
memorg vs Mem0: Structured Memory vs Vector Memory for LLM Agents
A practical comparison of memorg and Mem0 for agent memory — when structured schemas beat vector recall, when they don't, and how to combine them.
mpl vs MCP: A Compliance and Audit Layer on Top of the Agent Protocol
MCP defines how agents talk. mpl defines what correct looks like. Why production agentic systems need both — and how to compose them.
promptel vs DSPy: Declarative Specification vs Programmatic Compilation
A practical comparison of promptel and DSPy for prompt engineering — when to use a declarative specification language, when to use a programmatic compiler, and how they compose.
Programmable Databases: Why We Built liath Twice
The story of building a Lua-native database in Lua, then rewriting it in Rust with RocksDB — and what the performance tells us.
Deliberative Search: When the Engine Reasons Before It Retrieves
Why traditional search retrieves first and ranks later — and how slorg inverts this by understanding intent before fetching results.
Persistent Memory for Long-Running Agents
What happens when LLM agents need to remember across sessions — structured memory schemas, retrieval strategies, and the memory-context distinction.
Vector Search Without the Cloud: memista's SQLite-Backed ANN
Building approximate nearest-neighbour search on SQLite in pure Rust — and why you might not need a dedicated vector database.
Ephemeral Credentials and Zero-Trust AI: Rethinking API Security
Why AI agents need scoped, time-limited credentials — and how perishable implements zero-trust patterns for LLM API access.
Prompt Lifecycle Management: From Extraction to Deployment
A practical framework for managing prompts as versioned dependencies — tackling drift, regression, and reproducibility.
Better Rankings with Fewer Comparisons: Multi-Armed Bandits for Efficient Ordering
How compere uses MAB algorithms to rank items effectively with minimal pairwise feedback — applications in search and recommendation.
Formalising Prompts as First-Class Research Objects
Why treating prompts as typed, portable artefacts changes how we reason about LLM behaviour — and how promptel implements this idea.
From English to Optimal: How savanty Bridges Natural Language and Constraint Solvers
Describe optimisation problems in plain English and receive mathematically guaranteed solutions — no PhD required.
Intelligent LLM Routing: Spending Compute Where It Matters
How route-switch uses MIPROv2 to automatically select the right model for each query — balancing cost, quality, and latency.
Autonomous Mobile Agents: ukkin's Architecture for On-Device AI
Building AI agents that browse, observe, and automate tasks entirely on-device — the autonomy-safety spectrum on mobile.
Building mullama: What We Learned Replacing Ollama from Scratch
A post-mortem on building a local LLM serving layer — llama.cpp integration, model management, and where existing tools constrain research.
Running Language Models on Your Phone: The llamafu Experiment
What happens when you run a full LLM on mobile hardware with zero cloud dependency — memory, latency, and model quality on consumer devices.
Sandboxing Untrusted Code in Zig: The zviz Architecture
How zviz uses Zig's comptime capabilities to build gVisor-inspired sandboxing with near-zero runtime cost.
Why We Write AI Infrastructure in Rust (and Zig, and Go)
Language choice as research methodology — how memory-safe, deterministic-performance languages produce falsifiable systems claims.
Compiling Trading Signals: sigc and the Quantitative Hypothesis Pipeline
From visual signal specification to verified Rust executable — how sigc turns alpha hypotheses into production-ready code in minutes.
Open Science in AI: Why We Publish Everything
The case for radical openness in AI research — reproducibility, falsifiability, and community trust through public research software.