Writeups
Source-grounded explanations from our conversations and reporting.
ComfyUI: Engineering the Workflow Behind AI Art
A second image-generation pass became a model-composition tool—and made local inference, memory management and extensibility central to creative control.
Containing Agent Chaos: Make the Environment Independent
Dagger’s approach to coding agents starts with their working environment: isolate parallel work, preserve reusable setup, and let humans inspect what happened.
Context Engineering for Agents: What to Keep, Retrieve, and Rebuild
A research agent’s growing tool history turns context into an engineering problem—one that reaches into retrieval, multi-agent coordination, memory, and the architecture around the model.
Cursor’s early bet: redesign the editor around the model
From CAD operations to code edits, Cursor’s early development showed why useful generation needs context, tools, and a workflow people can inspect and steer. This historical snapshot accompanies the original recording published August 22, 2023.
Cursor’s Third Era: From Writing Code to Operating Agents
Configured cloud computers let agents run applications, demonstrate changes, and work in parallel. The harder handoff is turning that output into software people can confidently ship.
CuspAI: Turning Materials Discovery into a Search Workflow
A materials search engine needs generators, progressively tougher evaluations, experimental feedback, and chemists who can recognize missing requirements.
Datasets 101: What a Model Actually Learns From
How tokenization, filtering, data mixtures, and training rights shape a model’s knowledge, deployment costs, and benchmark results.
Debugging the Internet: CodiumAI’s Case for Specialized Coding Agents
Generating tests is one step toward a larger goal: keeping specifications, tests, and code aligned, with developers deciding what the software should do.
Designing Inference Around Agents — Part 2 of 3
Part 2 of the NVIDIA Brev and Dynamo conversation: adapting inference to changing workloads, giving agents access to compute, and distinguishing longer runs from useful autonomous work.
DevDay 2025: From Tool Calls to Production Agents
Apps SDK gives developers an interface inside ChatGPT. AgentKit brings workflow design, evaluation, and deployment together—with consequential limits at launch.
DevDay Recap, Part 1 of 4: Managed Threads, Custom GPTs and the Cost of Convenience
Part 1 of 4 follows developers’ first reactions to OpenAI’s announcements: less conversation plumbing, more tools, and practical questions about billing, context, control and reliable action.
DevDay Recap, Part 3 of 4: From Agent Demos to Dependable Applications
Part 3 follows expense assistants, browser agents, code search, and open models through the practical questions behind DevDay: usable context, reliable outputs, and responsibility for automated actions.
DevDay Recap, Part 4 of 4: Faster Answers, Parallel Tools, and Room to Build
Part 4 of 4 moves from the Keep AI Open party to Julius AI’s code-execution workflows: why latency matters, how parallel tools could shorten repairs, and where startups can build alongside a platform.
DevDay, Part 2 of 4: Configurable Assistants and Platform Risk
Part 2 follows the move from conversational configuration to connected workflows—and the consequences for retrieval control, hosting costs, and developers building on OpenAI.
Diffusion for Molecules: From Plausible Structures to Useful Drug Design
How Genesis combines physics-guided co-folding, demanding evaluations, and laboratory feedback—and why useful drug-discovery agents depend on all three.
Distillation, borrowed answers, and the limits of SWE-bench
Why API traffic cannot easily reveal training intent, why the strongest model may be a poor teacher, and how coding benchmarks can reward knowledge their tasks never supplied.
Dolly: cheap instruction tuning, harder questions
An April 2023 conversation with Mike Conover about shaping model behavior, building open datasets, and evaluating what applications actually need.
Dreamer: Building a Personal Agent Operating System
Shared tools, coordinated agents, inspectable code, and the product judgment behind personal software.
Dust: Building Workplace Agents from Tasks That Already Work
Useful workplace agents depend on bounded instructions, carefully prepared company data, and a product employees can shape around their own work.
Elicit: Making AI Research a Process You Can Inspect
From oversight experiments to reusable notebooks, Elicit builds research workflows whose steps can be trained, checked, and scaled.
Emulating Humans Means Engineering the Whole Conversation
Chatbots for adult creators must coordinate persona, sales, memory, and boundaries. Convincing language is only one part of the system.
Enterprise AI Search Starts with the Missing Document
Glean’s workplace search problem opens a broader discussion of ranking, tool use, model costs, and knowing which work to automate.
ESM and the Data Barrier to Programmable Biology
Learning evolution’s constraints from protein sequences opens a route to structure prediction, molecular design, and discovery. Extending that approach to cells will require new data and experimental feedback.
Every Agent Needs a Box
Enterprise agents need useful context, bounded access, a workspace, and human oversight. Making those pieces fit an organization is as much a workflow problem as a model problem.
Exa’s Neural PageRank: From Predicting Documents to Finding Every Match
Understanding a query is only the start. Exa’s search ambitions depend on retrieving the right documents, clarifying intent and deciding where more computation is worth the cost.
Fireworks’ bet on open models and compound AI
Fireworks combines model serving, workload-specific optimization, and systems that connect models to tools and data. Its competitive bet is that inference engineering will matter more as open models improve.
FlashAttention 2: faster attention starts with moving less data
FlashAttention preserves the attention computation while reducing memory traffic. Its development shows why mathematical ideas, hardware constraints and usable software have to advance together.
From API Stability to o1’s Reasoning Budget — Part 2 of 3
Part 2 moves from practical API integration to launch-day o1 questions: model stability, retrieval, batch processing, speech, and the cost and visibility of reasoning.
From Assistant Demos to Dependable Systems — DevDay, Part 3 of 4
Part 3 of 4 follows builders from budget approvals and browser purchases to codebase search, guardrails, and open models—with usable context and reliable evaluation as recurring tests.
From Borrowed GPUs to Lexica: Making AI Capabilities Useful
GPU marketplaces, image search, model training, and browser agents in Latent Space’s May 2023 conversation with Sharif Shameem.
Public beta. Model source and teaching reviews passed; human editorial review is pending. Original articles and recordings remain separate.