Trending ML Papers

What it is. Crafter is a system that automatically produces the kind of polished diagrams and infographics that show up in research papers and slide decks — and crucially, it can output them as editable vector files (SVG) you can tweak later, not just flat images. Instead of relying on a single image model, it orchestrates a team of specialized AI agents (a planner, a critic, a refiner, and so on) that pass a shared, structured 'spec' of the figure between them, gradually fixing mistakes like garbled labels or misaligned arrows. The authors also release CraftBench, a 279-figure benchmark that tests this across diagrams, posters, and infographics, started from text, sketches, or partial layouts.

Where it fits. Most image generators are tuned for photographs or art and stumble on structured visuals where every box, arrow, and label has meaning — rerolling the prompt just produces a different set of mistakes. Prior work split into two camps: 'agentic' pipelines that drove image models toward methodology figures (still raster, still uneditable) and code-based tools that emit TikZ or similar (editable, but visually plain). Crafter sits in the recent shift toward treating the model as one part of a larger 'harness' — an orchestration layer with memory, critics, and verification — rather than asking a single model to get it right in one shot.

Why it matters. Scientific and product diagrams are one of the last big chunks of knowledge work where generative AI has mostly stayed out of the loop, precisely because the outputs need to be exact and tweakable. If this approach holds up, designers, researchers, and PMs could generate a draft figure from a rough sketch or a paragraph, then open it in a vector editor and adjust colors, labels, or layout — closing the gap between 'AI made an image' and 'I can ship this slide.' The caveat is that the system is still bounded by the underlying image backends and was evaluated mostly by AI judges, so real-world polish on long-tail layouts is an open question.

What it is. GrepSeek teaches a small language model to answer questions by running shell commands like grep over a raw text collection, instead of querying a pre-built search index. Think of it as giving the model a command line — it can search for keywords, filter results, and chain operations together to track down evidence across millions of documents. The team trains it in two phases (first imitating worked-out search trajectories, then improving via reinforcement learning) and pairs it with a parallel execution engine that runs these searches up to 7.6× faster while producing identical results.

Where it fits. The standard recipe for letting an LLM use external knowledge is RAG (retrieval-augmented generation): a separate retrieval system embeds and indexes documents, then hands top-K hits back to the model. That works, but it's locked to whatever chunks and rankings the index was built with, and it struggles with questions that need exact matches or careful cross-document tracing. GrepSeek joins a recent wave of work — inspired partly by how coding agents already use grep over codebases — that lets the agent operate on the raw corpus directly. Concurrent efforts have shown the idea works with very large proprietary models, but at a cost of hours per query; this paper is about making it cheap.

Why it matters. If a small open model can search a large document store by running text-processing commands, you remove a whole tier of infrastructure: no vector database, no embeddings to maintain, no re-indexing when documents change. That could matter most for enterprise search and compliance settings where data is constantly updating and exact phrasing matters. The paper itself is honest about the trade-off: lexical search misses things when the question and the answer use different words, so this is more 'add to your toolbox' than 'replace your retrieval stack.'

What it is. Code2LoRA takes an entire code repository and, in a single pass, produces a small custom plug-in (a LoRA adapter — a lightweight bundle of extra weights, originally a popular trick for cheaply fine-tuning large models) that teaches a code language model that repo's APIs, conventions, and quirks. Crucially, at the moment a developer asks for a completion, the model doesn't have to read piles of project files for context — that knowledge is already baked into the plug-in. A second variant, Code2LoRA-Evo, keeps the plug-in fresh as commits land by maintaining a recurrent memory that updates on each diff. The team also releases a 604-repository benchmark to measure how well methods hold up as code changes.

Where it fits. AI coding assistants today face a basic tension. To give good suggestions inside a specific project, they need to know that project's code; the dominant ways to do this — stuff the context window with retrieved files via RAG, or fine-tune a separate model or adapter per repo — are either expensive at every keystroke (RAG) or expensive every time the codebase changes (fine-tuning). Hypernetworks (small networks that generate the weights of larger ones) have been explored for adapting models to tasks or documents; Code2LoRA scales that idea to whole repositories and adds a mechanism for handling continuous code evolution, which prior approaches assumed away.

Why it matters. For anyone building developer tools, the cost of context is a huge constraint — long context windows are slow and expensive, and per-repo fine-tuning doesn't survive a normal week of commits. If hypernetwork-generated adapters work in production, an IDE could carry a tiny per-project 'brain' that stays current with diffs and adds zero latency to each completion, which changes the economics of repo-aware coding copilots. The reported gains are still in the single-digit-percentage range and the evaluation focuses on Python assertion completion, so generalization to other languages and richer tasks (refactors, multi-file edits) is what to watch next.

What it is. COLLEAGUE.SKILL is a pipeline that turns the messy traces a person leaves behind — chat logs, docs, code reviews, emails, even speech transcripts — into a portable 'skill' package that an AI agent can load and use. The package has two tracks: a capability track (a coworker's review checklist, decision heuristics, common pitfalls) and a behavior track (how they communicate, what their boundaries are). Each skill is versioned, can be inspected, edited via natural-language feedback, rolled back, and installed across different agent hosts like Claude Code. The repo and gallery already have substantial real-world adoption (the paper reports ~18.5k stars and 215 contributed skills).

Where it fits. Agent platforms have been converging on the idea of 'skills' — folders with instructions, scripts, and reference material that agents pick up on demand. What hasn't been solved is how to actually make a useful skill when the knowledge lives in someone's head or scattered across years of artifacts. Existing memory and persona features capture fragments, but the result is opaque prompts or hidden state. This paper proposes treating the output as a real artifact: something with provenance, a correction history, and explicit consent boundaries, especially important when you're trying to package judgment from a real person rather than a documented procedure.

Why it matters. Most teams have a 'tribal knowledge' problem — the senior engineer who knows why the build fails on Fridays, the PM who knows which customers will quietly churn. If their expertise can be distilled into an inspectable, correctable package an agent can use, onboarding, handoff, and continuity-of-knowledge get a lot easier. The trade-off the paper is careful about is governance: turning a person's traces into a portable artifact raises real consent and privacy questions, especially for the 'celebrity' and 'relationship' variants, so the design's emphasis on inspectability and rollback is as much about safety as engineering.

What it is. OCC-RAG is a pair of small language models — just 0.6B and 1.7B parameters — purpose-built to answer questions strictly from a provided document, citing literal quotes and refusing to answer when the document doesn't actually contain the answer. To train them, the team built a 3-million-example pipeline that synthesizes multi-hop questions (where you have to combine clues across passages) and unanswerable ones (where the right move is to abstain). The result: these small models match or beat general-purpose models 2 to 6 times their size on standard benchmarks for multi-hop reasoning, factual grounding, and knowing-when-to-decline.

Where it fits. RAG systems — where a language model answers questions from documents the system retrieves for it — are the workhorse of enterprise AI, but big general models often quietly fall back on what they 'remember' from training rather than what the document actually says, which produces confident-sounding hallucinations. OCC-RAG is part of a growing argument that for narrowly defined jobs, small, task-specialized models are not just cheaper but actually more reliable than big general ones, because they can be trained explicitly to ignore their own memory and to abstain.

Why it matters. Faithful, citation-grounded QA is exactly what most enterprise document-search and customer-support products are trying to ship — and the failure mode that gets companies in trouble is the model confidently making things up. A sub-2B-parameter model that can run on a single modest GPU (or potentially on-device) while behaving more like a careful junior analyst than a confident generalist is a meaningful operational win: lower latency, lower cost, easier to audit, and easier to deploy in regulated environments. The honest caveat is that benchmark wins on faithfulness don't fully translate to real, messy documents, so this is best read as evidence that the small-and-specialized recipe works, not as a finished product.