Tag
Everything tagged AI, most recent first.
64 entries
Judged the 6th Global AI Hackathon, Hack-Nation's largest to date (5,500+ applications, some 2,500 builders across 12 hubs), run with the MIT Club of Northern California and the MIT Club of Germany. Scored seven projects on the jury.
Reviewer for GroundLM 2026, the workshop on grounding and retrieval-augmented language models at EMNLP 2026 (Budapest, Hungary).
The last five parts were the recipe. This one is the kitchen at dinner rush: the two engineering tricks that get DSpark running inside a real serving system, and the speedups it delivers there.
Part six of the speculative decoding series, the finale. Parts one to five were the idea. This one is the engineering: two tricks that get DSpark running inside a live serving system. First, do not ship the whole dictionary of scores between machines while training the guesser, ship the compact summary and do the last step locally. Second, a scheduler that cannot wait, because real GPU speed rises in jagged steps and the pipeline cannot pause, so it predicts the batch size ahead of time. Plus the real production speedups. Plain words, an analogy, a diagram, and two auto-playing visualizers.
DSpark's last machine, on its own: how it decides exactly how much of the draft to check, across everyone it is serving at once, like loading a delivery van to its sweet spot.
Part five of the speculative decoding series, and the last of three that open up DSpark one machine at a time. This one is the expediter, the paper's greedy scheduler. It decides how much of the draft the big model should check, across everyone it is serving at once, and the rule is neat: pool every guessed word, sort the most likely to pass first, and keep loading the batch while the words-per-second keeps climbing, then stop at the peak. Explained with a delivery-van analogy, a diagram, and an auto-playing visualizer. Short, one idea, and it wraps the three machines.
DSpark's second machine, on its own: the AI's confidence scores are overconfident, like a forecaster who says 90% but is right 70% of the time, so DSpark corrects them to match reality.
Part four of the speculative decoding series, and the second of three that open up DSpark one machine at a time. This one is the honesty check. DSpark puts a confidence number on every guessed word, but those numbers run high, the same way a weather forecaster who says 90% is often right only 70% of the time. Calibration shaves them down until they match reality, without changing their order, which is what lets the next machine trust them. Plain words, a worked example, a diagram, and an auto-playing visualizer. Short, one idea only.
DSpark's first fix, on its own: how a tiny cheat sheet, the same trick your phone uses, makes each guessed word fit the one before it.
Part three of the speculative decoding series, and the first of three that open up DSpark one machine at a time. This one is the cheat sheet, the paper's Markov head: the same trick your phone's predictive text uses, where the word you just typed nudges the next one. It explains what a score even is, why the fast guesser is blind, and how a small nudge breaks the tie, with a worked example, a diagram, and an auto-playing visualizer. Short, one idea only.
A fast drafter gets sloppy toward the end, and checking its whole guess wastes the big model's time. DSpark makes two small changes that fix both, and the output never changes.
Part two of the speculative decoding series, in plain language. Part one left a dilemma: a draft model is either accurate but slow or fast but sloppy, and checking a long shaky draft wastes the big model's time. This part walks through DSpark, an open method from DeepSeek, one small change at a time. First, let each drafted word see the word before it, so the fast drafter stops contradicting itself. Second, score each word's chance of surviving, multiply those scores into a running number that only falls, and stop checking the moment it stops being worth it. Two interactive visualizers, one of them auto-playing through the whole cycle, and the production numbers, with no change to the output.
When a document has a structure, stop shredding it. Navigate it.
Part six of the RAG series. The default RAG recipe chops a document into chunks, embeds them, and retrieves by vector similarity. For a long, structured document that throws away the one thing that made it readable: its structure. Vectorless RAG keeps the document whole, builds a table-of-contents tree, and has a model reason its way to the right section, the way a human expert uses a table of contents. This covers why similarity is not relevance, how tree-navigation retrieval works, where it fails, when to reach for it, and when plain vector search is still the right tool. With an interactive navigator.
Writing one token at a time makes a large model slow. Speculative decoding speeds it up by letting a small model guess ahead.
Part one of a series on speculative decoding, the trick that lets a large language model generate text faster with no change to the output. This part covers why one-token-at-a-time is slow, the lossless draft-and-verify rule that fixes it, and the real difficulty: the draft model. It walks through the two families of draft models and the flaw in each, autoregressive drafters that are accurate but slow, and parallel drafters that are fast but decay down the block. With two interactive visualizers. Part two covers how DeepSeek's DSpark gets the best of both.
Why agent reliability lives in the scaffolding, not the model.
When an agent works in production, we credit the model. When it fails, the cause is almost always in the harness around it: the loop, the tools, the context, the guardrails, the checks. The harness is the part you actually own.
AI Engineer World's Fair 2026 talk: your coding agent is creating review debt, the accumulating gap between the code an agent produces and the code humans have actually reviewed, trusted, and understood. Five signal families and ten deterministic checks turn that gap into a single defensible score, validated across 524 real pull requests.
Four spec revisions, an official registry, the Linux Foundation, and the ecosystem that adopted it.
The closing piece of the MCP series: the four revisions that shaped the protocol through its first year and a half, the official registry and MCP Apps, the move to the Linux Foundation and open governance, how it went from one release to an industry standard, and where the 2026 roadmap points.
The model writes the code; the harness makes it correct by running it.
A coding agent that only writes code is a fancy autocomplete. The thing that turns a plausible diff into a change you can merge is the code harness: the sandbox, the tools, and the loop that runs the code and reads the real errors.
Agents are in production and doing privileged things, but the guardrails did not arrive with them. This PlatformCon talk lays out a Java and Spring Boot pattern that makes an agent quote a versioned tool contract before any tool runs, with a gateway that validates, governs, and audits every call.
A three-layer evaluation framework in Java + LangChain4j for AI-agent trust testing: policy compliance, judge-based answer safety, and tool-trajectory validation, wired into CI as a build-time gate.
Judged Day-Zero: Agents in the Wild, an adversarial agent field test presented by Efficient Frontier Labs (Oakland, CA).
OAuth 2.1, the resource-server model, RFC 8707, and the threats the protocol cannot solve for you.
The security axis of MCP: how authorization works on the HTTP transport with OAuth 2.1, the server-as-resource-server model and RFC 8707 resource indicators, the later OIDC discovery and incremental-consent refinements, and the three threat classes, token passthrough, confused deputy, and prompt injection via tool output, with the guard for each.
The control loop is where you design termination, budgets, and recovery.
When an agent misbehaves, the loop is usually the culprit, not the model. Loop engineering is the deliberate design of when to keep going, when to stop, and what to do when a step fails.
JSON-RPC, the lifecycle handshake, and the two transports, stdio and Streamable HTTP.
How MCP messages actually move. The JSON-RPC base, the initialize handshake and capability negotiation that set up every connection, and the two standard transports, stdio for local servers and Streamable HTTP for remote ones, plus why the old HTTP-plus-SSE transport was replaced.
Retrieve fast and roughly, then read the top few closely and reorder. The second pass that fixes the first.
The closing part of the search series. First-stage retrieval is fast but ranks crudely. A reranker takes the top candidates and scores each one by reading the query and document together with a cross-encoder, then reorders. This covers the bi-encoder vs cross-encoder split, why it must be a second stage, and where it lives in production, with an interactive retrieve-then-rerank demo.
Runtime contract gate for agent tools
A runtime gate that evaluates every agent tool call against a versioned contract derived from an approved OpenAPI artifact, blocking or escalating calls when the live tool surface drifts.
Keyword search and vector search fail in opposite directions. Run both, merge the results, and you keep the strengths of each.
Part six of the search series. BM25 is strong on exact terms and blind to synonyms; vector search is the reverse. Hybrid search runs both and fuses the two ranked lists. The hard part is combining incompatible scores, which Reciprocal Rank Fusion (RRF) sidesteps by using ranks instead. Worked examples plus an interactive RRF explorer.
Build-time trust tests for LLM agents
A JUnit 5 framework that catches enterprise AI-agent failures before release by turning allowed-tools, grounded-answers, and golden-trajectory expectations into regression tests that run in CI.
Operating an LLM system means making a fuzzy, non-deterministic thing measurable.
LLM systems are hard to operate because outputs are open-ended and non-deterministic. LLM ops and eval is the discipline that makes them measurable: evals as tests, tracing, regression gates, and a flywheel that turns production failures into your next test set.
Tools, resources, prompts, sampling, roots, elicitation, organized by who is in control.
The heart of MCP is six primitives: three the server offers (tools, resources, prompts) and three the client offers (sampling, roots, elicitation). This piece defines each precisely, with method names and the one question that organizes them, plus what the 2025-11-25 revision added around them: async tasks, tool-calling in sampling, richer elicitation, and icons.
Give up on exact, and you can search a billion vectors in milliseconds. This is the graph that makes it happen.
Part five of the search series. Exact kNN is O(N) and hopeless at scale, so production vector search gives up exactness for speed with approximate nearest neighbor. This explains the dominant method, HNSW: navigable small-world graphs, greedy search, the layer hierarchy, and the M / efConstruction / ef knobs, with an interactive graph-search explorer.
Generating working MCP servers straight from the OpenAPI specs you already have: the mechanical field mapping, why it takes a library and not a script, the production traps, and the guardrails to set before an agent touches real users.
When you stop comparing characters and start comparing coordinates, search can finally match meaning.
Part four of the search series. Keyword and fuzzy search match characters, so they miss synonyms. Vector search embeds text into geometry, where similar meaning becomes nearby points. This covers embeddings, the two distance metrics (cosine vs euclidean), exact k-nearest-neighbor search, and the scaling wall that forces the approximate methods in the next part. With an interactive kNN explorer.
Turn any OpenAPI spec into an MCP server
Turns an OpenAPI 3.x specification into a working Model Context Protocol server, exposing the generated tools over Streamable HTTP for any MCP client with no glue code.
What the Model Context Protocol is, the pieces it is made of, and the map of the rest.
The Model Context Protocol is how an AI application reaches the tools and data it needs. By mid-2026 it is a Linux Foundation standard with an official registry and support across the major platforms. This opening piece lays out the problem, the client-host-server architecture, the six primitives, and the map, anchoring a five-part series.
Exact match fails two ways users hit every day, typos and half-typed queries. Here is the machinery that forgives both.
Part three of the search series. The inverted index only matches literal keys, so a typo or a half-finished word returns nothing. Fuzzy search fixes typos with edit distance (Levenshtein), computed by a small dynamic-programming grid and run at scale with automata or n-grams. Prefix search fixes as-you-type with tries and FSTs. Worked examples throughout, plus an interactive edit-distance grid.
What a framework makes easy, and what it hides.
An Agent SDK is a packaged harness: the run loop, tool interface, memory, model abstraction, and tracing, ready to wire together. The value is what it makes easy. The risk is what it hides.
How a search engine turns a match into a score. The workhorse ranking function, and the two knobs that tune it.
Part two of the search series. Matching finds candidates; ranking decides the order. BM25 is the default text scorer, and it is really three forces: term frequency with saturation, document-length normalization, and term rarity (IDF). This walks the intuition with worked examples, the exact formula, and the k1/b knobs, then hands you an interactive score explorer.
Before a word can be indexed, it has to be prepared. The quiet pipeline that decides what your search can ever match.
Part of the search series. The inverted index does not store raw text; it stores terms, and text analysis is the pipeline that turns one into the other: tokenize, lowercase, drop stopwords, stem to a root, expand synonyms. The same analyzer must run on the query, and getting it wrong silently breaks search. With an interactive analysis pipeline.
Every search engine does the same four things. Once you see them, the rest is variations.
The opening piece of a search series. Search is four steps that never change (index, parse, match, rank) and a hundred choices about how to do each. This part lays out the inverted index, boolean retrieval, why matching is not ranking, and the precision-recall tradeoff every later technique is a bet on, with worked examples throughout.
Peer reviewer for the Trustworthy AI for Good (AI4GOOD) workshop at ICML 2026.
What an eval is, the types of eval, and the step-by-step for running one that tells you something true.
Eval is how you turn a fuzzy, open-ended LLM system into something you can measure. This is a practical guide to the types of eval, from exact match to LLM-as-judge to human review, and the six-step procedure for running one you can actually trust.
Judged the Google I/O kickoff pre-World Cup hack (San Francisco).
Judged AI Agents Hackathon #33, a virtual hackathon run by Open Source for AI and the r/AI_Agents community.
GraphRAG local and global search, the two multimodal strategies, the lineage from RETRO to CAG, each with its own analogy and visualizer.
The last piece of the RAG series: when flat vectors are the wrong shape for the knowledge. GraphRAG with local search and global search as separate ideas, multimodal RAG's two strategies (shared embedding space and translate-to-text), the family tree (RAG-Sequence, RAG-Token, REALM, Fusion-in-Decoder, RETRO, Atlas), the long-context-versus-RAG debate, and cache-augmented generation. Each with an everyday analogy and an interactive visualizer.
Iterative, adaptive, FLARE, Self-RAG, corrective, speculative, and agentic RAG, each with its own analogy and its own visualizer.
The control-flow axis of RAG, pattern by pattern, each with an everyday analogy and an interactive visualizer: iterative and multi-hop RAG, adaptive RAG, FLARE, Self-RAG, corrective RAG (CRAG), speculative RAG, and agentic RAG. How each adds a loop, and then adds judgment to the loop, and how to stop at the least autonomous pattern that answers your questions.
Peer reviewer for the Agents in the Wild (AIWILD) workshop at ICML 2026.
Fixed-size, structure-aware, sentence-window, parent-document, summary indexing, RAPTOR, and late chunking, each with its own analogy and visualizer.
The indexing axis of RAG: why chunking is the quiet make-or-break decision, and the ladder of strategies, each with an everyday analogy and interactive visualizer: fixed-size chunks, structure-aware splitting, sentence-window retrieval, parent-document (small-to-big), summary indexing, RAPTOR's hierarchical tree, and contextual and late chunking. How to decouple the unit you search from the unit you read.
Sparse, dense, hybrid, learned-sparse, late interaction, re-ranking, and contextual retrieval, each with its own analogy and its own visualizer.
The retrieval axis of RAG, method by method: sparse keyword search (BM25), dense embeddings, learned-sparse (SPLADE), late interaction (ColBERT), hybrid fusion with RRF, cross-encoder re-ranking, and contextual retrieval. Each gets an everyday analogy, the real definition, and its own interactive visualizer. How each decides what counts as a match, a worked reciprocal-rank-fusion example, and why real systems combine several.
RAG is not one technique. It is a design space, and this is the map of it.
Retrieval-augmented generation started as a single idea and turned into a whole family of designs. This is the opening map: naive RAG, the advanced pre- and post-retrieval tricks, the modular mindset, and the five axes every variant moves along. It anchors a five-part series that walks every kind of RAG.
An incident-remediation agent behind a security envelope
A self-healing microservices agent that reasons over telemetry, deploy history, and logs via MCP and remediates production incidents behind an RBAC, ACL, OAuth, and human-approval envelope.
Peer reviewer for the First Workshop on Agent Skills at ACM CAIS 2026.
Judged the Nozomio Hackathon at Entrepreneurs First (San Francisco).
Artifact evaluator for the ACM Conference on AI and Agentic Systems (CAIS) 2026.
Judged AI Agents Hackathon #31, a virtual AI agents hackathon.
Peer reviewer for LT-EDI 2026 (Language Technology for Equity, Diversity and Inclusion).
Program committee peer reviewer for SASIGD 2026.
Judged HackwithBay 2.0 (San Francisco).
Judged the Total Agent Recall AI agents hackathon (San Francisco).
Judged the r/AI_Agents March Demo Day, run by Open Source for AI.
Mentored teams building AI projects at the Weber State University AI hackathon.
Judged the Cursor Community Hackathon in Heilbronn, Germany (remote).
Judged the AI Agents February week-long hackathon run by Open Source for AI and the r/AI_Agents community.
Blast radius and incident-to-deploy correlation
A platform that maps service topology, indexes logs and traces, correlates incidents to deployments, and computes blast radius, giving evidence-grounded answers to 'why did this deploy fail?' and 'what breaks if I change this?'
Judged The AI Collective Tri-Valley Holiday AI Demo & Mixer (Danville, CA).
A working engineer's primer on the prompt patterns that actually move accuracy in production LLM systems: system-prompt structure, few-shot, chain-of-thought, structured output, and the anti-patterns that quietly hurt.
Hallucination-free PPT to narrated video
Converts PowerPoint decks into narrated explainer videos where every narrated claim traces back to specific slide content, using a content-addressable evidence index, a closed-loop verifier, and a dual-provenance knowledge graph.
Multi-hazard risk, and a model that predicts it
A free, open-source multi-hazard risk assessment for any US address (HazardPrep) paired with an XGBoost engine that predicts FEMA disaster declarations up to 90 days ahead (HazardCast).
A short, intuitive take on Root Mean Squared Error, why squaring makes it punish large misses harder than small ones, and how to read it when judging a regression model.
