cloudkserg @cloudkserg

Recommended resource. Largest dataset of agent skills I’ve come across. Great for mining cool ideas and patterns for your agents.

DAIR.AI @dair_ai

a day ago

How many agent skills are actually out there? There are ~3.8M SKILL.md files across 282,200 public GitHub repositories, nine months after Anthropic published the format as an open spec. This research mined all of them into a dataset. Skills resist the usual software mining.

9 26 169 23K 195

Impressive new paper from Meta. (bookmark it) Scaling laws assume model size and training data act on loss independently. This work introduces Skaling law, which couples capacity and data through a single interaction exponent. The extra term cuts mean absolute percentage error by 1.5x to 3x across both interpolation and extrapolation. The largest corrections land in the data-scarce and heavy-overtraining regimes where the standard Chinchilla and Kaplan forms drift. Paired with a sparse grid restricted to low-compute runs, it extrapolates the full grid using roughly 10x less compute than a uniform sweep. Why does it matter? Deployment now happens well past compute optimal. A law that stays accurate there, and that can be fit from small runs, changes how a pretraining budget gets planned. Paper: arxiv.org/abs/2608.07222 Track more trending AI papers in our academy: academy.dair.ai

Are we ready for an agent-native memory system? First, what does that even mean? It's memory built for an agent that keeps running, not a store you bolt on at the end. It has to hold facts across sessions, update them when they change, drop the stale ones, and hand back the right piece when the agent asks. A real data system, not a pile of saved chunks. A new study checked whether anything out there actually does this, and what decides the answer surprised me. It takes 12 agent memory systems and splits each into four stages, covering how memory is represented, extracted, retrieved, and maintained. Then it checks which stage decides whether the agent stays correct. Turns out it's write time, not query time. The systems that stay reliable under fact updates and cross-session reasoning are the ones that add structure as the memory is written. The graph-based methods lead right there. The flat stores fail the same way every time. An LLM pulls out entities and relationships with no schema, and the graph fills up with generic nodes that nothing downstream can filter. A few things follow from this: → Structure has to be set at extraction. Once the graph is built from untyped nodes, no query can recover a distinction the extractor never made. → Updates return stale facts. Append-only and freeform stores keep handing back old versions, which the paper calls hallucinations of the past. → A bigger model does not save it. Swapping the backbone moves the scores but rarely changes which pipeline wins, so the memory's behavior is set before generation runs. The paper also weighs the cost. The heavily structured systems pay for it, sometimes orders of magnitude more time per query, and the win only holds when the upkeep stays local instead of rewriting the whole store on every change. So the takeaway is less about picking a winner and more about where the structure lives. Decide it at write time, keep the maintenance cheap, and retrieval has something real to rank. Retrieval only ranks what the extraction chose to keep. Here's the paper: arxiv.org/pdf/2606.24775 To dive deeper into agent memory systems, my co-founder wrote a full article on exactly this. It walks through defining the schema as a Pydantic ontology in Zep, with custom entity and edge types, source and target constraints, and the extraction pipeline that turns raw conversations into typed, queryable memory. This memory system is 100% open-source: github.com/getzep/graphiti You can read the article below.

Akshay 🚀 @akshay_pachaar

3 months ago

x.com/i/article/2058…

18 81 561 309K 1K

Bigger context windows are a dead end. this paper proves it A new CS survey quietly reframes the whole game: the thing that separates a real AI agent from a fancy autocomplete isn't the model - it's memory engineering It turns agent memory into an operating system: write → manage → read. the agent decides what to keep, what to merge, and what to forget The wild part: a stateless model becomes a self-evolving agent without adding a single parameter Meanwhile most devs still dump text into a vector DB and call it memory This is the map everyone will be copying in 6 months Read it below. bookmark it before it blows up

NO1ennn @N01ennn

2 weeks ago

x.com/i/article/2083…

27 59 495 738K 1K

This is F*cking gold andrej karpathy joined anthropic to lead a team using claude to accelerate its own pretraining research, teaching claude to help build the next version of itself. that's real, confirmed directly. the "two anthropic seniors made his loop 1000x better with graph engineering" claim is not something i can verify anywhere, and i'm not going to invent a personal testimonial to make it sound more credible than it is. what is genuinely worth reading: anthropic's own published claude cookbook on knowledge graph construction, extract, resolve, assemble, query, real and public, no leaked breakthrough required. read that, then check the article below.

CyrilXBT @cyrilXBT

2 weeks ago

x.com/i/article/2084…

29 49 419 738K 1K

New paper worth reading: HarnessCompass (Save this one to read later) It automates the harness improvement loop without touching the base model Three rules: - Generalization gate: rejects any change tied to a specific case (task IDs, test names, repo symbols). What gets in has to be a reusable criterion, not the fix for one task - Agent feedback: beyond reading traces, they ask the agent what got in its way, before telling it whether it failed. Then every complaint is validated against the traces - Separate branches: code changes and criteria changes (prompt, memory) run in parallel on different files. Best one wins, useful parts of the other get salvaged At Hedgineer.io we ended up at almost the same criteria Adapting the main harness and its data, observability over traces and agent behavior, and detecting improvements with prior evaluation to decide whether they go to code or to criteria. Paper: arxiv.org/abs/2608.01918

Lilian Weng @ OpenAI on Harness Engineering a deep breakdown of harness design patterns, workflow automation, persistent memory via file systems, and how modern agents like claude code actually work. the best blog post I've read all month. link: lilianweng.github.io/posts/2026-07-…

Airbnb just published how they run evals internally, and it reads like a job description for an AI engineer Three layers. Programmatic checks first, an LLM judge second, humans last and only to calibrate the judge. The numbers they work to: golden sets of 50 to 100 examples that have to include failures, judges calibrated to high 80s or 90s agreement with a human, measured with Cohen's kappa. 5% of live traffic sampled every day. The admission that makes it real: roughly three quarters of their LLM-generated reference answers came out different on every labeling run. Their eval was measuring its own noise. They got a full cycle from weeks down to a day, mostly by caching identical outputs and training tiny LoRA adapters. Nobody in a job ad calls this eval engineering, but this is the work. Full breakdown in the article below. Bookmark this

Yarchi @undefinedKi

3 weeks ago

x.com/i/article/2078…

12 41 335 1.0M 1K

OpenAI pays FDE engineers up to $785K/year. In this 40-minute talk, OpenAI's Head of FDE revealed how they deploy AI inside real companies: 02:46 - Why Morgan Stanley became their first FDE case 09:05 - Build with eval-driven development 16:01 - Watch an LLM reroute a supply chain 24:33 - Build an FDE team 29:06 - Avoid their biggest mistake Most developers build AI demos. FDE engineers make them work in production. Demos are the old workflow. Deployment is the new one. This 40-minute talk replaces most $500 enterprise AI courses. Bookmark and watch it today Then read the full FDE roadmap below

Lunar @LunarResearcher

3 weeks ago

x.com/i/article/2082…

18 170 873 2.4M 3K

finally got through the Kimi-K3 paper. my notes on the post-training side: 1. SFT -> creates synthetic data built from earlier kimi models to cold start the base, then multi stage verification and human in the loop annotation on top. -> serialized with the XTML chat template. -> quantization aware training starts here. mxfp4 weights, mxfp8 activations. 2. RL -> scaled across three domains: general tasks (experience, vision, reasoning etc), general agents (long horizon, deep research), coding agents (swe, kernel, web dev). -> each domain trained at three efforts, low high max, so 9 experts total. -> partial rollout for sync rl. instead of waiting for all K rollouts in a group it proceeds once a fraction is done, the paused ones get queued and resumed next iteration from sandbox state. -> once all K land they run policy optimization, algorithm just inherited from k2.5. -> correction to my earlier read: it's per token regularization, not importance sampling. that's the thing that survives the staleness. -> reasoning effort: each prompt gets a budget from the sft model, exceed it and reward flips to -1. one threshold param tuned per effort for low high max. -> non-verifiable tasks use an agentic generative reward model that builds a rubric on the fly then scores against it. 3. MOPD -> per token reward is a clipped log ratio of teacher to student, clipped at Rmax so no single token blows up the update. -> it's a dense signal that drops into the existing rl loop, so partial rollouts and the long horizon infra still work. that's the actual win. -> mxfp4 quant aware post training, same quant scheme across train and inference. they call it removing the mismatch, but that only removes the precision half kernel and engine gaps are still there. 4. Synthetic RL -> harness treated as composable modules so the model doesn't overfit one setup. they use kimi code, claude code, codex, openclaw, hermes. -> synthetic env built from a self growing knowledge graph. start from seed root nodes, expand coarse to fine through web exploration across domains. 5. RL Infra -> co-located rl. training and inference on the same gpus, plus partial rollouts as referenced in kimi-k1.5. -> external kv cache pool with write back. idle prefixes spill to cpu dram only on eviction and prefetch before reuse, training state offloads to nvme to make room. -> rollout auto throttling scheduler, concurrency driven by live kv pressure instead of a fixed guess from average trajectory length. -> gradient buffer reuse for non policy forwarding. reference weights streamed into the policy's grad buffers chunk by chunk, no extra allocation.

keyboard_arrow_left Previous keyboard_arrow_right Next

Finally a good paper testing if file-system based memory for LLM agents is worth it. First, what does this look like? Deployed agents keep long-term memory as a folder of markdown files they read and reorganize with ordinary file tools. Two assumptions had never been checked. That an agent can keep a growing store organized as memories accumulate, conflict, and go stale. And whether the organization pays for itself. Organized stores roughly halve retrieval cost when the material is large. No agent in the study converted organization into better answers, and in the growth study the store degraded for every management agent except the strongest one. Changing the tool set alone reshapes the memory store as strongly as swapping the model. Paper: arxiv.org/abs/2607.26637 Track more trending AI papers in our academy: academy.dair.ai

An Anthropic engineer did what everyone says cannot be done, and explained it simply enough for anyone to copy Bun is a JavaScript runtime used by millions of developers. It was written in Zig, a language almost nobody knows, which made hiring and contributing hard. So they decided to rewrite it in Rust. That meant rewriting half a million lines of Zig into a million lines of Rust, and rewrites of that size normally take a team a year or fail outright. Jarred Sumner did it in eleven days. He did not sit there correcting the AI. He built something that corrects itself. First he wrote down the rules for how to do the work. Three hours, no code. Then he did three files out of 1,448 as a test, looked at what went wrong, improved the rules, and deleted the three files. He never kept a to-do list. The folder was the list: anything without a finished version is still to do. So he could stop and restart whenever he wanted. Every finished piece got checked by two other AIs that could not see how it was made, because one that watched the work happen just agrees with it. The slow checks ran once at the end, not after every file. And whenever the same mistake appeared a third time, he did not fix three files. He fixed one sentence in the rules and ran that part again. Full breakdown in the article below Bookmark this

Yarchi @undefinedKi

4 weeks ago

x.com/i/article/2080…

16 50 324 443K 950

This paper is f*cking brilliant A computer science paper establishes harness engineering as the primary determinant of AI agent reliability The result: the ETCLOVG seven-layer architecture unifies execution sandboxes, tool protocols, context state, lifecycle graphs, observability, verifiers, and governance The crazy part is how harness engineering boosts performance without changing the underlying model Optimizing the execution harness alone increased SWE-bench coding benchmarks from 6.7% to 68.3% Most developers try to fix agent failures by upgrading to larger LLMs This framework shifts system reliability from model weights to deterministic harness architecture Read the complete paper + article below Bookmark it for future reference

beamnxw ./ @beamnxw

3 weeks ago

x.com/i/article/2080…

74 542 3K 1.2M 8K

Super interesting new work from NVIDIA. (bookmark it) They suggest building agents as Python objects. Very cool idea and I think it could a lot with agent reliability. More below: Agent development today spreads across prompt templates, tool schemas, callback code, and workflow graphs. NOOA replaces all four with one abstraction. An agent is a Python object. Its methods are the actions the model can take, its fields hold state, its docstrings are the prompts, and its type annotations act as contracts. A method whose body is "..." gets completed at runtime by a validated LLM loop. A method with a normal body stays deterministic Python. That single convention puts the boundary between probabilistic and deterministic behavior right in the source. Agent behavior becomes testable, traceable, and refactorable with the same tools you already use on the rest of your codebase. NVIDIA reports six model-facing ideas combined on one surface, including pass-by-reference over live objects and model-callable harness APIs for context and events, evaluated on SWE-bench Verified, Terminal-Bench 2.0, and ARC-AGI-3. Paper: arxiv.org/abs/2607.20709 Learn to build effective AI agents in our academy: academy.dair.ai

RL and post-training details of Kimi-K3: 1/ i like how Kimi K3's post-training approach decouples capability discovery from capability fusion. instead of requiring a single policy to master all behaviors under one blended RL objective they first develop a high-quality SFT cold-start, train single-task RL experts on diverse behaviors and finally unify the behavior in one model through multi-teacher on-policy distillation (MOPD). as the SFT stage relies on synthetic agent trajectories produced by former domain-specialized Kimi models (which are subsequently verified multi-stage by hand) the base policy is already knowledgeable on how to reason, use tools and perform long-term tasks on trajectories. RL then focuses on learning better execution rather than discovering primitive interaction semantics. finally the MOPD phase presents one practical constraint in specialism: a particular specialization is often helpful in training but deploying multiple individual multi-trillion-parameter checkpoints is impractical both in terms of cost and reliable routing. 2/ there are three domain teacher families in the RL stage: general tasks, general agents and coding agents. general task teacher represents general reasoning and judging ability (which covers vision ability, factual faithfulness, searching ability and knowledge work in professional domain). general-agent teacher represents continued execution ability, which cover long-horizon assistant workflow, deep research and structured writing. coding-agent teacher represents software engineering ability, general coding behavior, GPU kernel optimization, web development, and so on. IMO the choice of these groups is reasonable because Kimi does not train one teacher for each benchmark or skill but train across a distribution of related task and domain. in this way the expert has a coherent behavioral specialization and avoid simply memorize a particular benchmark's format, verifier, tool schema and so on. each domain teacher is trained at three reasoning-effort levels: low, high and max producing nine teachers in total. kimi controls effort using a task-relative token budget rather than assigning the same fixed limit to every problem. 3/ the nine-teacher structure therefore represents a two-dimensional capability matrix: domain specialization × reasoning effort. a coding-max teacher can take more tokens to explore a repository, run tests, fix failed tests and rethink its approach, whereas a coding-low teacher is explicitly optimized to arrive at good output under the constraints of lower output and tool limits. the same would be true for a research and assistant workflows. i think this is a better approach than just training one teacher and adjusting the number of tokens allowed at inference time is that optimal policy itself can change as the budget changes. 4/ MOPD compresses the teachers by choosing the teacher that corresponds to the sampled domain d and effort level e, then evaluating the student on that student's own generated trajectory. for each student-sampled token the teacher provides a clipped log-probability-ratio reward that compares the teacher's probability for that token to the student's. when the teacher's probability for the token is greater than the student's that token receives positive reward, and vice versa for overproduced negatively-rated behavior. The teachers generate evaluations on prefixes of the student's own generated plan so the evaluated states are those the student will run in deployment. 5/ i'd say Kimi K3's RL system is asynchronous for trajectories but not a completely async actor-learner system. they say it augments a standard synchronous RL framework with partial rollouts (N prompts and K sampled responses per prompt). they run NK independent agent-worker trajectories but can start to train policy as soon as λNK's finish rather than waiting for the longest individual episode. they pause aborted trajectories with state preserved (model prefix and sand box) and stick them on a priority queue to have them resumes some later in the learning time. these long agent trajectories may end with very old policies - kimi claims per-token regularization is able to deal with extreme off policy settings although they not disclose total loss. they are able to do this by mixing training and rollouts on same machines, separate KV cache for agents outside the machines for some specific reason, throttling agent on the fly when too large, etc and also making agents checkpointable agentenvs micro VMs. important idea here: Kimi doesn't discard slow individual agent it actually let those long ones across the iteration line.

keyboard_arrow_left Previous keyboard_arrow_right Next

New research from NVIDIA. They just dropped a PyTorch-native training framework for agentic RL. (bookmark it) Paper summary: Molt is a PyTorch-native agentic RL framework with an unusual design target. The codebase should be compact enough for a researcher to hold in their head, and for an AI coding assistant to read and reason about in its entirety. Agentic RL research is constant algorithm modification, new estimators, new pipeline stages, new rollout schemes. In mainstream frameworks each change threads through layers of trainer, distributed backend, and rollout glue, and that cost falls on the researcher every iteration. The agent stays an ordinary program. One asynchronous loop trains multimodal and mixture-of-experts policies while never training on a token it did not generate, staying consistent in tokens, policy versions, and model semantics. Leanness does not cost throughput. Under a matched, fully asynchronous protocol Molt comes out statistically comparable to a state-of-the-art Megatron-based stack. Readable by an AI coding assistant is now a stated design constraint on research infrastructure. Recipes and containers are open source at github.com/NVIDIA-NeMo/la… Paper: arxiv.org/abs/2607.21653 Learn to build effective AI agents in our academy: academy.dair.ai

x.com/i/article/2081…

ANDREJ KARPATHY JUST RELEASED A 12-PAGE GUIDE ON BUILDING SELF-IMPROVING MULTI-AGENT GRAPHS.

x.com/i/article/2077…

x.com/i/article/2078…