I’m excited to share a new repo: Agent Skills for Context Engineering Instead of just offering a library of black-box tools, it acts as a "Meta-Agent" knowledge base. It provides a standard set of skills, written in markdown and code, that you can feed to an agent so it understands how to manage its own cognitive resources. github.com/muratcankoylan/Ag… Most agent failures are not model failures; they are context failures. This is still an experimental project. The goal is to establish a platform-agnostic standard for context engineering that can be used in Cursor, Claude Code, Copilot or Codex. skills/ context-fundamentals: What context is, why it matters context-degradation: How context fails (lost-in-middle, poisoning) context-optimization: Compaction, masking, caching multi-agent-patterns: Orchestrator, swarm, hierarchical memory-systems: Vector RAG, knowledge graphs, Zep tool-design: Building tools agents can use evaluation: Testing and measuring agent systems I believe this is a good start, showing developers how to approach context engineering rather than relying on ready-made tools. You will also find the aggregated research documents I used to build these skills in the repo. The skills are synthesized from technical blogs on context and prompt engineering that I bookmarked, AI Labs' documentations, and Anthropic Skills examples. Try the 7 Skills, created using Antrhopic's Skills template format. Experiment with the provided scripts and references, and feel free to contribute to the repo.

I believe cross-profession transfers like this still seem underexplored. This weekend we looked at how people building 3D animation engines for agents think about spatial layout and control, and brought that into AI filmmaking. By treating staging as a first-class planning step (a top-down map the agent builds and checks before generation), we got more consistent eyelines, screen direction, and lighting than we usually get from prompt-only workflows. Here for example the higher-quality result came from the transfer of another field's new technique and repo, not from pushing harder on existing AI filmmaking techniques. So with AI, borrowing how another profession already reasons about a shared problem can actually produce better results than staying inside your own field’s current practices.

Good post on how the process of creation is changing. This quote grasps it: “slowing down does lower your error rate, but mostly because you're doing less of everything. We'd rather get faster...”

Wow this is such a cool skill for visualizing how CLMs work! 🤩 Thanks for making and sharing it!

New skill: self-managed-context (make the agent's context an editable file) It explains how to build agents that decide what to keep, update, or remove from the information they use to do their work. It can archive a long log while keeping the exact error, update its progress notes, or remove outdated information. Those edits then change what the model sees on its next turn. 1- Keep the system instructions and original task protected, outside the editable file. 2- Write the remaining conversation to a file, with labels for each message. 3- Let the agent edit that file using its usual code tools. 4- After each command, read the file back and use the updated messages for the next model call. Loading the skill (github.com/muratcankoylan/Ag…) alone into a fixed harness won't create live context editing, but it can help an agent build and then operate a harness that supports it. I gave the skill to a coding agent and had it build the harness itself. The task is a long stream of server logs that doesn't fit in the window. The agent reads it in 18 chunks, about 10k tokens in total, with a 5.5k budget. It has to report one incident ticket exactly and the final value of every config key. Same model & budget, three setups: 1- Model manages its own context 2- Harness forces a summary at 75% full 3- Keeps everything The video shows a real GPT-5.4 run. - Self-managed solved it 3 out of 3. - Keep-everything overflowed 3 out of 3. - Forced summary also solved it 3 out of 3. On GPT-5.4 the self-managed agent re-processed about 24% fewer prompt tokens than the forced summary. When it edited, it cut hard, so little was left after the edit to re-process (one edit took 5,537 tokens down to 771). On GPT-4.1 it saved nothing. It edited near the top of its context but kept most of what was below, and every edit forces everything after it to be re-processed. This is a small test at about 2x context pressure. The paper goes up to 24x, but imho the video below and the skill are a good way to start understanding the technique.

I built this at the gym with Devin Mobile I’ve been pretty skeptical of coding agents on mobile. I just I don’t need my phone becoming another IDE. But yesterday I had the idea to share our Jev research. I told my agent to use our branding and pull in everything we’d done over the last few days and create an interface and a video. That 3-min work is now seen by 250k people, good win. Devin’s been really helpful for my our team. If you’re building a startup, here’s our referral link to apply for their startup program ($65,000 in credits) 👉 devin.ai/startups?ref=dfs-od…

We gave Jev 2,029 real phone calls. No transcripts or audio; it never heard a word. Our AI receptionist's calls were reduced to pure structure, meaning turns, tool calls, workflow stages and timing. During the calls, Jev made 38,012 turn-level forecasts at 118 ms median latency, reviewed every call with five typed questions and produced 10,145 answers in 26 seconds with 256 requests in flight. The experiment was zero-shot, with no fine-tuning or examples from our data. We compared Jev's forecasts with what actually happened in the EHR. By the halfway point, Jev could meaningfully separate calls that would book from those that wouldn't (AUC 0.78), and near the end it ranked them correctly 94% of the time. Even though Jev over-focused on visible errors our agent usually overcomes, it's still pretty incredible that it analyzed thousands of real calls in seconds for only $3.

What if a film studio were just a set of files? That's what we've been experimenting with, and we've just started making our first films in it with Opus 5.5 and Seedance 2.5. On a set, a scene's decisions are spread across a writer, director, designer, DP, sound designer and editor. A single prompt written by one person, or one model, collapses all of that into one voice. It usually ends up as a mood board in words: "cinematic, moody, 35mm." But what the model actually needs is a causal specification: - Who wants what? - What physically happens? - Where does the light come from? - What do we hear, and why? - Where does the cut fall? We are rebuilding the crew as prompts, letting them make the decisions, and compiling those decisions into the language of one specific model. The test brief here was this: Napoleon walks into a secondhand bazaar in Canada. The absurdity is played as completely normal. It's for a mock resale brand called Twice. An agent, Devin harness, running Opus 5.5, reads and writes the system. A producer prompt casts roles and integrates their work. And we keep creative authority as Director. Each role is filled by a persona: a ~2,000-word simulation of a real creator's publicly documented working method. It covers what they notice first, what they refuse, and when they break their own rules. A generic "you are a cinematographer" collapses to the average. A specific method disagrees, and it has to give a reason. For this brief, the producer cast 14 of them. They work through shared files: each one reads what the others decided, writes its own proposal, and challenges the rest in writing. "Been through a few winters, that one." A silence. "So have I." Everything is first written as a model-neutral spec, then compiled for Seedance 2.5. Persona names never reach the model. The camera stays static on purpose. It's one more person in the room who doesn't care. The video below is the very first output: one generation, straight from the prompt the system wrote from the brief. It still has small mistakes. But agentic video editors are getting better fast (if you know good ones, drop them below). Soon the agent won't just write the prompt; it will review what the video model returns for that scene and send it back for another pass. That's the next step is a video generation factory, automated and run by agents from brief to final cut. We're still experimenting with different orchestrator architectures and context systems. This is really exciting, and we can't wait to share more details soon.

It's actually weird feeling to watch recursive self-improvement start working in your own harness, and to finally see the results. With Opus 5.5 and GPT-6 Astra, our harness now improves itself and agents do almost every step of it. 1. Agents write the evals. They turn failing call traces into versioned scenarios: caller persona, goal, the tools that should run, and the final state expected in the EHR. 2. Agents call agents. Simulated callers are wired to phone our deployed receptionist in real rooms, with real tools and a sandbox EHR, in text and audio, across both of our runtimes. 3. Agents grade agents. An LLM judge plus deterministic end-state checks score each call, and failures are clustered by runtime, tool and check. Agents then write one fix and one new scenario per root cause as a stacked PR. 4. Agents review agents. Reviewer agents critique every PR, findings get fixed with tests, and scenarios are rerun. A change proposed only if it passes on both runtimes. We still own merge and deploy, for now. We're early, but for the first time the loop is starting to close. I've never experienced a pace like this. It's getting faster so RAPIDLY.

A self-improvement loop for multimodal generation is here. We gave Opus 5.5, running inside the Devin harness, a 12-second clip generated by Seedance 2.5 along with the prompt that produced it. It essentially debugged the prompt like code. Opus audited the clip frame by frame, found details we had missed, traced several failures back to contradictions or underspecified constraints in the prompt, rewrote it, generated another attempt, and evaluated the result again. Opus did not receive a continuous video stream. It built its own inspection harness in a shell: - Adaptive sampling. ffmpeg at 2 fps across the clip, then 4 fps around critical windows like the camera reveal and dialogue. It assembled contact sheets so frames seconds apart could be compared directly. - Hypothesize, then zoom. It formed a claim and verified it using magnified crops from specific timestamps. This is how it caught a delivery rider wearing one helmet while carrying another, in a blurry region roughly 100 px tall that we had missed. - Rule reconstruction. It explicitly reconstructed the scene's constraints: which direction each signal should face, which traffic phase permits each movement, who should be speaking, and so on. It then evaluated the video against those constraints rather than just asking whether the scene looked realistic. - Audio as a separate channel. It ran faster-whisper with word timestamps, measured loudness in 0.5 s windows, and compared those events against mouth crops to infer who was actually speaking. It then produced a PDF with annotated figures and severity labels, while separating direct observations, model inferences, and vendor claims. Some apparent "video model errors" turned out to be prompt errors. Finding those required reasoning about the internal logic of the scene, not just inspecting pixels. Opus also built its own evaluation harness with minimal instruction. On a fixed 11-criterion scorecard, the generation went from satisfying 2/11 criteria to 7/11 after the prompt revision. More interestingly, the eval made the remaining failure obvious. Explicit spatial constraints helped a lot. Temporal state changes were much harder. Once the scene layout was specified precisely, Seedance could usually render it. Binding a state transition at the right moment to the right object remained unreliable (I believe we need more context engineering and experiments here) We also ran the same task with GPT-6 Astra, and Opus 5.5 surfaced substantially more of the subtle inconsistencies and missing constraints.

i don't think nearly anyone, myself included, has truly internalized there'll soon be a machine better than us in every single intellectual & physical capacity deep down we all share a feeling that our 'entrepreneurship' or 'taste' or... is special & safe. it isn't. it's over

Ata's hands-on experience on film sets, now shaping how he makes AI ads and movies. Go follow my cousin if you’re working in this space. He shares the creative decisions behind the work. He’s also here with me in Toronto for a while. If you’re around and want to collaborate, hit him up. And if you can help with video model credits, we’ve got plenty of ideas!

When I tried GPT-Live-1 today, I felt deflated as I recognized behaviors we’d spent weeks trying to make reliable. For the past three months, I’ve been focusing on researching and building duplex voice agents, where I wrote thousands of lines across our harness and the experiments around it. Customers use parts of that work every day, the conversions are increasing drastically as we make our voice agents more reliable and expressive. This duplex voice harness/model (interaction runtime + kernel) problem has occupied most of my attention but tbh when I first started working with voice agents, I didn't know how challenging and complex they were. Duplex conversational timing, orchestration, acoustic turn-taking, micro-interruptions, prosody, and generalized noise etc are really hard problems. There are so many 'beautifully crafted"'voice demos but seeing them in production is almost impossible. A cough would interrupt the voice agent, it leaves the caller waiting for it to speak again. During a tool call, someone would change their decision before the earlier result returned. There are also many other telephony factors so it is not just an AI or research problem. Following those cases through the system led us to separate the part that speaks from the work running in the background. We’ve developed a kernel that controls what the agent can do and checks what happened before it reports an outcome to the caller because the duplex models simply weren’t good enough yet. During this period, reading NVIDIA’s PersonaPlex and Nemotron VoiceChat work helped me understand where the models were heading; Thinking Machines’ Interaction Models approach to keeping an interaction going during longer tasks connected with questions we were already working through. My first thought was how much of what I’ve been working on will we no longer need? This is another great example of how harnesses are compressing into models. That's why always build your harness and repo that you can destroy every 6 months and build it from scratch again. It should be very fluid and modular, so you can easily bring the frontier capabilities. That's why building a duplex harness that happens to use ASR, STT, LLM, TTS models is not a good solution since duplex is commoditized today. Build a harness where the duplex model itself is a replaceable component. This is valid for any software field. After spending months with these problems, I appreciate the work behind GPT-Live more deeply. Through client delegation, anyone can connect GPT-Live to existing harnesses, where the models you choose work with your tools. Thank you to the OpenAI team. This is a big win for anyone building solutions to benefit humanity.

The world of R&D is forking into two paths: the token-abundant research, and the token-starved research. The future is in the former - evidentially, the progress by today's top AI industry teams and neolabs is breathtaking, where researchers’ human brilliance is super charged by AI’s assistance. Every research university president should be reading this report and reflecting on what the future of higher education research should be. openai.com/index/research-ac…

Getting ready to publish my complete guide to RL for LLMs tomorrow morning. Although the post contains many of my own thoughts / learnings, it is also a synthesis of so many great resources that have been published over the years: - The RLHF Book (rlhfbook.com/) by @natolambert - Reinforcement Learning by Richard S. Sutton and Andrew G. Barto - Spinning Up in Deep RL (spinningup.openai.com/en/lat…) from OpenAI - Build an LLM (sebastianraschka.com/llms-fr…) and Reasoning Model (sebastianraschka.com/reasoni…) from Scratch by @rasbt - Various notes (joschu.net/blog/kl-approx.ht…) and papers (TRPO, PPO, etc.) from John Schulman - Policy Gradient Algorithms (lilianweng.github.io/posts/2…) by Lilian Weng - A Vision Researcher’s Guide to RL (yugeten.github.io/posts/2025…) by @YugeTen - From REINFORCE to Dr. GRPO (lancelqf.github.io/note/llm_…) by @qingfeng_lan - Async GRPO in the Wild (yumoxu.notion.site/async-grp…) by @yumo_xu - Open RL infrastructure like TRL (huggingface.co/docs/trl/en/i…) and OpenInstruct (github.com/allenai/open-inst…) I highly recommend reading all of them. They’ve truly helped me to learn so much.