16 papers
Foundations & Infrastructure
The substrate: LLM internals, GPUs, serving systems, and the theory underneath.
- Papers
- 16
- Read time
- 5.3h
- Avg length
- 20m
Fundamentals of Building Autonomous LLM Agents
A practitioner's anatomy of an autonomous LLM agent — it decomposes the agent into four cognitive subsystems (perception, reasoning/planning, memory, execution), catalogs the concrete techniques for each, and shows how to wire them into a closed loop that can actually drive a GUI or web task end-to-end.
- Read
- 16 min
- Source
- arXiv:2510.09244
Building Autonomous AI Agents based AI Infrastructure
Put autonomous agents in charge of the boring, expensive, 3-AM parts of running cloud/AI infrastructure — scaling, fault recovery, energy, security — using a perceive → decide → act → learn loop, and a single RL-driven agent beats both rule-based automation and humans on utilization, recovery time, and energy.
- Read
- 14 min
@skills: Attention Is All You Have
Installing an agent skill secretly bundles three separate jobs — fetch the text, keep the text, and let it fire on its own — but only the last one needs a permanent slot in the model's system prompt, so `@skills` splits them apart and lets 56,804 skills be reachable while fewer than ten sit resident.
- Read
- 18 min
- Source
- arXiv:2608.12610
Adaptive LLM Routing under Budget Constraints
A query router that learns *online* — from cheap thumbs-up/down feedback instead of a labeled dataset — which LLM to send each query to, warm-started with human-preference data and capped by a budget-aware "knapsack" policy, hitting 93% of GPT-4's quality at 25% of its cost.
- Read
- 16 min
- Source
- arXiv:2508.21141
Agentic Web: Weaving the Next Web with AI Agents
The web is mutating from a place humans search and click into a place where autonomous agents discover each other, call services, and transact on your behalf — and this survey maps the three layers (intelligence, interaction, economics) and the new plumbing (MCP, A2A, agent-attention markets) you'll need to build in that world.
- Read
- 28 min
- Source
- arXiv:2507.21206
Efficient Agents: Building Effective Agents While Reducing Cost
A controlled ablation of every part of an LLM agent (backbone, planning, tools, memory, test-time scaling) on the GAIA benchmark, showing that most of the "sophisticated" machinery adds cost without accuracy — and that a deliberately stripped-down config keeps ~97% of performance for ~57% of the cost.
- Read
- 14 min
- Source
- arXiv:2508.02694
Fast and Simplex: 2-Simplicial Attention in Triton
Replace the pairwise dot-product inside attention with a three-way (trilinear) product so each model parameter buys more reasoning power — letting you hit better math/code/logic scores with the same number of training tokens, which matters now that high-quality data, not compute, is the bottleneck.
- Read
- 16 min
- Source
- arXiv:2507.02754
Foundations of Large Language Models
A 277-page textbook that walks you through the entire lifecycle of a modern LLM — pre-train it, scale it, prompt it, align it to humans, and squeeze more reasoning out of it at inference time — explaining the actual math behind each stage rather than just naming the techniques.
- Read
- 45 min
- Source
- arXiv:2501.09223
From LLM Inference to Agentic Workloads
When you run real AI agents at scale, the language model is no longer the main cost — the sandboxes, search, retrieval, idle-but-live sessions, and framework overhead are — and this paper measures exactly where the time, memory, and money actually go, then shows four small fixes that reclaim 29–460% of it.
- Read
- 18 min
- Source
- arXiv:2608.15127
GPUs: How They Work and How to Make Them Fast
A modern GPU is a factory that can compute far faster than it can fetch data, so almost every trick for making machine-learning code fast is really a trick for touching slow memory less often — and FlashAttention is the poster child of doing exactly that.
- Read
- 22 min
Language Models are Injective and Hence Invertible
A decoder-only Transformer almost never maps two different prompts to the same hidden state, so the hidden states you store, log, or cache *are* the user's text in disguise — and the paper gives you a linear-time algorithm (SipIt) that reads it straight back out.
- Read
- 18 min
- Source
- arXiv:2510.15511
Persona Vectors: Monitoring and Controlling Character Traits in Language Models
Find the single direction in a model's activations that "means" a trait like *evil* or *sycophancy*, and you get a cheap dial to monitor it live, undo it after fine-tuning, prevent it during fine-tuning, and pre-screen training data that would induce it — all from a one-sentence description of the trait.
- Read
- 16 min
- Source
- arXiv:2507.21509
Ray: A Distributed Framework for Emerging AI Applications
Ray is a distributed compute framework that runs millions of tiny, heterogeneous tasks per second with millisecond latency by combining a stateless "remote function" model, a stateful "actor" model, a logically-centralized control store, and a two-tier scheduler — making it the substrate that lets you scale RL and agentic workloads with a few `@ray.remote` decorators instead of a custom cluster.
- Read
- 18 min
Role-Aware Language Models for Secure and Contextualized Access Control in Organizations
Can you bake org-chart permissions directly into an LLM so it answers the CEO but politely refuses the intern asking the same question? This paper fine-tunes models to do exactly that — and measures how well it survives jailbreaks, prompt injection, and corrupted role labels.
- Read
- 16 min
- Source
- arXiv:2507.23465
Towards a Science of Scaling Agent Systems
A controlled 180-run study showing that adding agents helps or hurts in predictable ways governed by measurable task properties — and distilling that into one equation that picks the right architecture for 87% of unseen tasks.
- Read
- 18 min
- Source
- arXiv:2512.08296
Understanding Deep Learning
A single, internally-consistent textbook that teaches every modern deep-learning architecture — MLPs, CNNs, transformers, GNNs, GANs, VAEs, diffusion, and RL — as variations on one recipe (define a parameterized function, write a loss, minimize it by gradient descent), so you finish able to reason about *why* these systems work, not just call them.
- Read
- 28 min