I ship LLM features
you can trust in production.

tandaA fleet of coding agents around one shared queue, with a review gate before anything ships.

A small Python tool, with no dependencies, that runs roles of any agent CLI (Claude Code, opencode, Codex or your own command) around one SQLite queue. A scout fills the queue, builders take one item at a time, a reviewer sends work back or approves it, and the run ends by itself when every scout has finished and nothing is left to claim. Waiting is done by tanda, not by the agents: an agent only starts when there is an item for it, so idle roles cost no tokens. Each role may only set the verdicts it is allowed, an agent that exits without one leaves its item on HOLD for a human, and a local dashboard shows the queue and each item's history.

The open-source work below comes from the in-house version of this setup, a set of shell scripts I run every day; tanda is the clean, general rewrite of it, not yet the thing running in production. Running the in-house one taught me more than building it did. The queue never starves for builders; it starves for good candidates. Auditing a receptive repo module by module, comparing each provider adapter with its siblings, finds far more real bugs than hunting for unclaimed issues, which popular repos close within hours. Most rejected work fails on checks nobody writes down: a renamed repo hiding your own earlier PR, a PR template that asks for something only a human can provide, a project whose purpose is one you should not put your name on. Those checks now run before any code is read, and anything that needs a person (a CLA, a sign-off, a design call) waits for one.

Role: Design and implementation

llm-drift-lintA linter for LLM API calls that break when a provider changes or retires a model.

Static checks for Python code that calls the Anthropic, OpenAI and Gemini SDKs. It finds the calls, resolves the model id when it is a literal or a constant, and checks each call against what that model accepts today: sampling parameters newer models reject, reading content[0].text when the first block is now a thinking block, a forced tool_choice under thinking, a default model past its shutdown date on OpenAI, the Claude API, the Gemini API or Vertex. An upcoming retirement is a warning and a passed one is an error, and every message links the page the date comes from.

Every rule comes from a bug I fixed upstream, and the test corpus holds the real files from those fixes as they were just before and just after, with the findings a correct linter must report. False positives count as bugs: when a rule cannot tell which model a call uses, it stays silent. On sixteen large code bases (langchain, llama_index, crewAI, dspy, agno, semantic-kernel and others) the first six rules reported exactly two findings, and both were real bugs. The newer rules came out of the same loop: a pattern that keeps turning up in fixes becomes a rule, and the rule then finds the next repos to fix.

Role: Rules, model tables, test corpus

Weather-Aware Truck RoutingThe safest truck route, judged by the forecast for the hour the truck reaches each point.

A React + Django app built as a full-stack take-home. It asks Valhalla for three truck routes with the real gross weight, so roads with weight limits are respected, samples each route every 10, 25 or 50 miles, and gives every checkpoint an ETA from the router's own maneuver timings. Each checkpoint reads the hourly wind, rain and snow forecast for that ETA and gets a risk level from the brief's thresholds plus load rules: strong wind with a heavy load becomes Severe or No Travel. Routes are ranked by No Travel, Severe and High miles, then average risk, then travel time, and the map colours the chosen route by risk next to a 0–48 h forecast heatmap of the corridor.

Most of the judgment went into edge cases the brief left open. Its ranges share endpoints, so a value on a boundary goes to the higher band, because this is a safety tool; a stretch between two checkpoints takes the worse of the two, since over-counting dangerous miles is safer than under-counting them. The free services pushed back too: Open-Meteo rate-limits the shared IP of a free Render instance, so on a 429 the backend asks the browser to fetch the forecast points itself and send them back, and the ranking still runs on the server. The rules are pure functions with table-driven tests.

Role: Design, full build, deployment

Business Ops AgentAn agent that can only act through a protocol, and a harness that scores how it acts.

An MCP server exposing a small business's operations — catalog, booking capacity, stock, catering quotes, orders — as tools any MCP client can call: Claude Desktop, Cursor, or the LangGraph agent that ships with it. The agent holds no business rules; it does not know the catering minimum, because the quoting tool tells it. Add a tool to the server and the agent can use it with no change on the agent side. It runs on AWS Lambda behind a public Function URL, backed by DynamoDB, with the infrastructure in Terraform and a deploy on every push to main.

The evaluation scores the trajectory, not the answer — which tools were called, in what order, with what arguments, and whether every figure in the reply traces back to a tool result. That last check needs no judge model: pull the numbers out of the answer and confirm they appear in something a tool returned. It stays correct when an invented number happens to be right, because the question is whether the agent looked it up. It caught the agent claiming "I don't have that information" with zero tool calls, and caught it intermittently — the same case passed the run before, which is why the harness can repeat a scenario. Worth saying plainly: my scorer was wrong four times before it was right, and the first draft blamed the agent for its own bugs.

Role: Protocol server, agent, evaluation harness, deployment

Ask the GDPRAnswers over regulation, citing the provision — not the page.

A Retrieval-Augmented Generation assistant over the full text of the GDPR. Legal text imposes a constraint generic RAG ignores: nobody looks up page 14 of a regulation, they look up Article 17(1), and the page a provision lands on is an artefact of typesetting. So the corpus is not a PDF — a builder parses the Official Journal text from EUR-Lex into 414 provisions that carry their article, paragraph and chapter as metadata, and those travel with every chunk into the vector store. Ships in two modes behind one flag: an in-memory FAISS demo on a free 1 GB container with no database, and a pgvector-backed production path.

An assistant over legal text fails in an unusual direction. A miss announces itself — the user reads a vague answer and goes to the source. An invention is fluent, confident, and indistinguishable from a correct answer; attach a citation the model reasoned its way to rather than read, and it becomes more convincing, not less. So the harness measures refusal, not just recall: seven questions the Regulation does not answer but every model has read about — adequacy decisions by country, the wording of the standard contractual clauses, Schrems II, a CCPA penalty. Retrieval is scored on the cited provision rather than on matching text, which is stricter and removes the chunk-boundary false misses the old substring ground truth suffered. The measured failure is specific and worth naming: the right article, the wrong paragraph. Asked which administrative fine is the maximum, retrieval surfaces Article 83(4) first — the lower tier — with 83(5) third. The answer comes out grounded, because the agent reads all four passages, and the citation shown beside it is still the wrong paragraph, which is the exact failure the project exists to prevent. Sibling paragraphs share vocabulary and sit close together in embedding space, so a bi-encoder blurs the difference between a 10 million ceiling and a 20 million one; reranking is the next move.

Role: Corpus construction, retrieval pipeline, evaluation, deployment

ragciteThe measurement layer of the two projects above, extracted into a library.

Retrieval metrics, citation grounding, abstention scoring and tool-trajectory scoring, generalized out of the two harnesses above into a standalone package. It imports no LangChain, no vector store and no LLM client: you bring the retriever and, for abstention, the judge, and ragcite scores what they return. That constraint is the design — an eval library that owns your retrieval stack can only measure the stack it owns. Retrieval and grounding need no model at all, so they are deterministic and free to run on every commit, and a --min-hit-at-1 flag turns a run into a CI gate that exits non-zero on a regression. Without a threshold flag it always exits 0: a report, not a gate, by default.

The claim worth checking is that it was extracted from a production harness rather than written to look like one, so the example asserts it. It builds one FAISS index over the real GDPR corpus and scores the same 25 questions twice — once through ragcite, once through the original project's own independent metrics code — and exits non-zero if the two disagree. Sharing the index is the point: any difference can then only come from the scoring rule. They match exactly, hit@1 13/25, recall@k 17/25, MRR 0.59, which are the numbers that project prints for itself. It also refuses to run when the judge model and the model under test are the same, because that is a mistake I made and shipped: my own harness spent weeks marking a model as its own examiner before I noticed.

Role: Library, CLI, evaluation design

AI Website Chatbot WidgetAn embeddable assistant that answers for a business 24/7.

A drop-in chat widget for small-business websites. It answers customer questions — menu, hours, location, FAQs — grounded only in the business's own information, so it does not invent details. Reusable for any client by editing a single config file.

Role: Design, full build, deployment

Semantic RecommenderRecommendations from embeddings, not hand-written rules.

A recommendation engine built on vector embeddings with a feedback loop that refines results over time. Designed as a reusable backend for content platforms and e-commerce that have outgrown rule-based filters.

Role: End-to-end implementation