Speaker A
Hello community. I think we have a brilliant new idea, but there's also some risk attached to it. So, let's talk about it. We are not having any more the skill markdown file, but we have now operational skill states.
Google introduces operational skill states for AI agents, replacing conversational history with explicit state transitions for better long-horizon task management.
Ask about this video. Answers come from its transcript only — with the timestamp, so you can check them.
Generated from the transcript and can be wrong — check the timestamp.
Key Takeaways
- Skill states replace conversational history with explicit, validated state transitions for AI agents.
- This new method improves efficiency, accuracy, and scalability for long-horizon, complex tasks.
- The LLM proposes state changes while a harness applies them, separating decision-making from state management.
- Skill states outperform previous frameworks like LangGraph in benchmarks.
- Intelligent pruning of historical data is crucial for managing complex scientific and operational workflows.
What the video covers
- The video discusses a new AI architecture called skill states, replacing the traditional skill markdown files.
- Current LLM agents rely on accumulating conversational history, which grows large and inefficient over long tasks.
- Skill states represent explicit, structured state transitions rather than implicit conversational memory.
- This approach reduces token usage and improves efficiency by discarding intermediate reasoning traces after state updates.
- Examples illustrate how skill states track inventory changes in a warehouse scenario more effectively than conversational history.
- Skill states enable better handling of complex, long-term tasks such as scientific experiments with vast data streams.
- The method involves the LLM proposing state patches and actions, with a harness applying validated state transitions.
- Skill states outperform existing methodologies including LangGraph and other stateful frameworks in accuracy and efficiency.
- The approach was developed in cooperation with Purdue University and is expected to scale well for future AI systems.
- The video emphasizes the importance of intelligent data selection and state representation for advanced AI agent workflows.
Chapters
- 00:00Introduction to Skill States and Problem Definition
- 01:36Limitations of Conversational History in LLM Agents
- 02:56Examples of Current State Reconstruction Challenges
- 04:11Comparison with Existing Frameworks like LangGraph
- 05:21Introduction to Explicit Skill State Representation
- 06:23Warehouse Example: State Patching and Action Execution
- 07:29Handling Customer Orders with Skill States
- 08:32Complexity in Scientific Experiments and Data Correlation
- 09:48Mathematical Foundations and Procedural Skill Specifications
- 11:59Performance and Benchmark Results of Skill States
Full Transcript — Download SRT & Markdown
Speaker A
So, let's have a closer look. Skill state, what a nice idea. I mean, you know exactly what we're talking about. New memory architectures for our long horizon agents.
Speaker A
Now, at first let's start with defining the problem that we want to solve. In current LLM agent runtime, you execute some procedural skills here by repeatedly appending the reasoning traces, its actions, all the observations here from the environment,
Speaker A
and then the complete list of tool outputs. And all of this, if you put it together, if you append it together, you have a growing conversational history. And this is the way we do it currently.
Speaker A
Now, the execution state is represented implicitly within a natural language, let's say in English, and it must be reconstructed by our large language model at every single interaction because, you know, an LLM is, per definition, stateless.
Speaker A
So, as the execution horizons with real complex scientific, financial, medical task increases, both now the prompt size and also the volume of absolute information grows monotonically, making now the execution increasingly dependent here on interpreting the historical text of all the decisions that came before
Speaker A
the current decision, rather than maintaining here the current world state. So, let's have a look here. The old methodology is simple. We have a conversational history accumulation.
Speaker A
Let's say we have an environment. This is a warehouse where we have now a step one, item A arrived. The agent decides now, "Okay, I will store item A at or on the shelf 12." So, the result now after
Speaker A
the tool execution is success. Item A is now on top of shelf 12. Now, the next step two is shelf 12 remains requires here maintenance, for example, now. So, therefore, the job of the agent is, "I will move item A from
Speaker A
shelf 12 to shelf 31." Tool result, beautiful success. Item A is now on shelf 31.
Speaker A
From the environment, we got now here an instruction, "Hey, a customer ordered you this particular item A to be delivered to his home address, now." So, at step three, the prompt contains now the entire transcript, and I've shown it here to you. Beautiful.
Speaker A
So, this means the LLM must reconstruct now the present state of the system from this history. That item A was originally on shelf 12, it was later moved, therefore, the old fact is obsolete. The current location should be shelf 31, and
Speaker A
the current action is to ship the item that is now positioned at shelf 31.
Speaker A
So, this means the current state exists only implicitly inside the conversation. And now, think about this. If you have a 100-step or deep research over 5 hours, you can imagine, and you have to pay for each and every token. So, let's talk about
Speaker A
it. What is the solution? There's now this beautiful new idea that you say, "Wait a minute. We do have an intelligent AI systems, now. So, let's go now not with a skill markdown file, but let's go to the next step, the
Speaker A
higher complexity. This is a skill state definition." So, this means this is now a runtime architecture that reformulates here the procedural skill execution as an explicit state transition, rather than the conversational history accumulation that we have up until now.
Speaker A
And at this very moment, I thought, "Hey, wait a minute. No, no, no. This is not true because think about frameworks like LangGraph, no? We already have a mean mean I only I've seen it here in LangGraph that use
Speaker A
auxiliary structured state to orchestrate a workflow across the agent nodes." So, we do have something like a structured state.
Speaker A
However, if you don't go and check, and please do it yourself, I also did it, if you go, you see the system still rely on the conversational transcript as the primary reasoning substrate.
Speaker A
So, yeah, but not really. So, therefore, this is now the skill state ideas really going the next step. It is an evolutionary step. It is, yeah, foreseeable, but this is the first time to this year publication here exactly on
Speaker A
this definition that they defined, that they implemented it, they operated it, they have the validation, and let's talk about the result in a minute.
Speaker A
So, this skill state replaces now this substrate that we had here, the reasoning substrate from LangGraph, for example, by throwing out all the intermediate reasoning traces immediately after producing a valid state transition.
Speaker A
So, we are not talking about the conversation, but we are talking now a new state representation, and we are talking about the mathematical operation of having now validated state transition.
Speaker A
This is a complete different beast. So, this new method is really an explicit state transition.
Speaker A
It creates here a separate structured state space. Let me give you a simple example. I know you're going to laugh about the simplicity, but I like simple examples.
Speaker A
Step one, item A arrives. So, now we have here JSON now inventory empty, now observation item A arrived. The LLM produces now an action and a state patch.
Speaker A
So, we just have here the state patch is inventory now on shelf 12 we have item A. And it produces an action. The action is store the item A on shelf 12.
Speaker A
And the harness applies the patch. Notice the harness applies the patch, but the decision was done by the LLM.
Speaker A
Okay, and then after what what we have in our JSON, we have an inventory, the shelf 12 is now filled with item A.
Speaker A
This is already an explicit state transition. Yes, it can be as simple as that. But of course, it can grow in complexity almost astronomically.
Speaker A
So, step two. Step two is okay, shelf 12 requires now some maintenance. So, the LLM receives only, okay, procedure move item away from the shelf because the shelf requires maintenance.
Speaker A
So, the current state is inventory is shelf 12 item A. Last observation, shelf 12 requires maintenance. Therefore, it produces now a new state where we have now, okay, shelf 12 is null.
Speaker A
Shelf 31 has now the item A. And the action was move item A shelf 12 to shelf 31. Great.
Speaker A
So, you see the state becomes now, guess what? The result of all of this is the inventory has now shelf 31 item A.
Speaker A
All that happened before, all the history, all the reshuffling here, why we had maintenance here on shelf 12, who cares about it? If you want to send it out, you have to know where is your particular product placed in your
Speaker A
warehouse. You have to go there, take it, and send it out. Beautiful. So, this is the main idea.
Speaker A
So, if now a customer orders this item A, you just need to know the position of item A, and the observation from the environment is now the customer ordered item A.
Speaker A
And now we have this idea that LM doesn't need to know all the history.
Speaker A
When did the item arrive? Was it originally placed on shelf 12? Why does shelf 12 require maintenance? And you got it.
Speaker A
Now I might say you know this is so simple. Okay, let's increase the complexity. Now perform a scientific experiment on quantum system that you do not really understand the operational mathematics behind it. So which data will you now throw away? Which history
Speaker A
in the development of the project will you now throw away for this new skill state representation?
Speaker A
For the mathematical representation of all the thousands and millions of data stream and tens of millions of data point that you receive from your quantum experiment, which data have a correlation pattern? Which data are correlated in general? Which data are
Speaker A
correlated given your current mathematical theorem on quantum fluctuations? Which data are not represented by this?
Speaker A
How can you construct a new skill state understanding the complexity of the mathematical theorem behind this quantum system? So you see, just throwing away some historical data is a highly selective process. You need a lot of intelligence, a lot of
Speaker A
understanding to do this. Yeah, this is the result, of course. So the main question, you can reformulate this, no? What is cu
Speaker A
next action? Given here the skill description, my task, my query, my instruction what to do, and it has to know what is the current operational state.
Speaker A
And what is relevant from this operational state? So let's talk about here a little bit more on the mathematical interpretation here. What does it mean an explicit state transition?
Speaker A
Now, I think this is a formula that describes it all. Now, so let's have a closer look. What are we dealing with here?
Speaker A
Our sigma T, this is simply the state before an action T or at the action T.
Speaker A
And yeah, sigma T plus one is the state after processing here this particular step here, this particular action then.
Speaker A
Great. So, sigma represents here the structured execution state. And please notice it is a structured state.
Speaker A
So, where is it? This is now of course stored by a harness. Normally, as I showed you here in the simplest case as a JSON pro project. If you have higher mathematical complexity or if you enter into the physics, you go
Speaker A
with other mathematical representations. But in normal case, it's a JSON. So, if you're new to AI, why? Because why is it stored in the harness? Because the core LLM is stateless between the calls. So, this means you have to have here some
Speaker A
deterministic file system, the harness, some control loop that preserves and inserts this whenever it needs it for the next prompt here in the context window of the LLM.
Speaker A
What else we have? Yeah, P of course is the procedural skill specification. This means the fixed instruction file telling here this particular agent how to perform the task. I've showed you this in my last video on Wiki skills where we
Speaker A
have exactly here the work definition. O, guess what? It is the observation from the environment as I have shown you in my simple example. Our pi theta, theta is simply the neural network, the uh representation here of the tensor
Speaker A
weights here of the transformer architecture. So, this is simply our core LLM used here as an action policy instrument. And our guess what? This is the reasoning. So, this is the temporary reasoning at this particular step T but
Speaker A
done by the LLM. Yeah, and you validate and merge it and you have the environment and new observation and you loop again.
Speaker A
So, this is important if you're new to AI, why is the harness now such an important thing? Because the harness contains absolute important elements. You have the skill instruction there, the external state storage, the state schema, the prompt
Speaker A
construction, the JSON parsing, the patch validation, the state merging, the tool execution, and all the communication with the environment.
Speaker A
Remember, this is your our deterministic part. Because the probabilistic part, the LLM, the genius, the neural network, the hallucination of the LLM, this is here where the LLM decides, or let's say proposes here, the state transition, the particular action to be
Speaker A
taken. However, it needs the harness, the deterministic regularitive part here around the core of the agent LLM, because now the harness decides whether that proposal here that for a state transition has the correct data structure, and if so, and if the
Speaker A
guardrails apply, yes, okay, everything is green, then it applies this proposal for the state transition.
Speaker A
So, you see, the essential difference by this new idea is simple. In the old methodology that I used up until now is the events accumulate here in our traces, and the state must be reconstructed by the LLM to understand,
Speaker A
okay, where am I now? What is the state of the current system? What has been done in the past? Where how and how we arrived here at this particular state of the system, and what is not a new
Speaker A
observation from the environment, and what is my freedom, what can I decide, what am I allowed to decide on?
Speaker A
Now, in the new methodology, we have now suddenly a skill state. So, this means the events modify the complete state representation, the state description.
Speaker A
And history can be more or less thrown out, but only the not relevant part of history. And exactly this selection is not an easy one.
Speaker A
But what have we achieved? Have you noticed this on a mathematical level? This is now essentially a Markov state assumption. And this opens up now all the mathematical theorem that we had looked at in the last year on this
Speaker A
YouTube channel. Because if we can start with a Markov state assumption, we have so many methodologies already in place that are valid that we can apply immediately on the skill state dynamics.
Speaker A
Great. So, the AI says now, and this is this is something that really gives me some goosebumps. The AI says now, "Hm, given what is true now and what I just observed, which variables must change and what action should I take?"
Speaker A
This is now a complexity in the process of arriving at a particular decision for a particular task for a given complexity.
Speaker A
That the AI decides what is true now in this moment, in this system, in this environment.
Speaker A
This is something absolutely fascinating. Because think about it. This question is more or less, "Hey, what information is still required here by me as an AI system to decide on a future action?" And somehow you have to throw away all
Speaker A
the historic data that will not contribute to any decision on the future action. But can you feel that this is here uh a confrontation of the different time axis that we have here for the complexity of the system?
Speaker A
So, I think that the redesign of this particular new state space can only be done with a true understanding, and again this this human word true applied to AI, of the state complexity given the query complexity, and And course given
Speaker A
the complexity of the environment feedback. So, is this a simple problem? No, if you look at this from a mathematical point of view.
Speaker A
Wow, this is this is a challenge for a weekend, yeah. Yeah, what are the results? So, let's say you are here the creator of this new idea, and it turns out, oh yeah, it is a little company called Google. So, published August 26,
Speaker A
2026. And in cooperation with Purdue University, we have skill.state. So, this has scalable long horizon agent skills now in a different mathematical complexity that we have to code in a different way.
Speaker A
I think this is a beautiful representation here screenshot by the paper about your arches here. So, what you have is here on the left side the traditional skill execution, on the right side you see the new skill state
Speaker A
runtime. And you see the prompt context change significantly because we are not operating anymore with the conversation here history, with the previous observation, or with the previous reasoning of the agent, because all of this has been now condensed into a
Speaker A
state, into an execution state, into a runtime. Okay. Now results. This is here by Google the warehouse management long horizon scaling using Gemini 3 flash, beautiful.
Speaker A
And I have here LangGraph that you see the best model up until now for stateful.
Speaker A
And you see here the score in the first column, and you see beautiful beautiful.
Speaker A
So, this new skill state here, the very last line in each block, outperforms every other methodology including the stateful LangGraph methodology that maybe you used up until now.
Speaker A
But then, let's look here at the last column in this. This is here the tokens consumed. This means that this is the tokens that you pay for.
Speaker A
And if we start here simple, yeah, at the horizon of 10, we have here okay, LangGraph has 10,000 tokens and this new skill state has 5,000 tokens. So, you see yeah, okay, this is okay.
Speaker A
But, let's go here to more complex tasks. Let's go here something that runs 2 hours, 3 hours.
Speaker A
So, suddenly we have 6 million tokens for a pure memory summarization. And this is important. This new methodology is not a memory summarization because look, the memory summarization and uses your operational in a real-world test 6.1 million tokens.
Speaker A
The stateful LangGraph uses here for this particular job 5.0 million tokens. And the new skill state methodology uses 122,000.
Speaker A
And this is a difference that you have to pay for. And this is a difference in time and this is a difference in precision because remember, skill state outperforms here on the metric of score accuracy all other methodologies and this includes
Speaker A
memory summarization and LangGraph. So, this is a simple, but wow, on the other side a highly complex idea to implement mathematically and then on a code basis because let's see, you're not in a simple warehouse operational facility, but you are doing some medical
Speaker A
experiments on highly complex financial scenario development or you are in theoretical physics and you have a quantum experiment.
Speaker A
So, yeah. But, the idea, the idea is simple and beautiful. Yeah. State recovery. You know, if you have state recovery problems, look at this. This new skill state just outperforms everything else because the recovery steps are exactly zero in the
Speaker A
test as presented by Google. So, here we go. And then I said, okay, let's do now some new benchmark. Let's come up with some new ideas for some open-ended task with some complex search, with some complex generational problems with complex tool use, and
Speaker A
let's evaluate this new methodology now on some particular benchmarks here. Yeah, Sierra tell engine whatever if you don't know it.
Speaker A
Now guess what? For Gemini 3 flash, turns out again, we have here our react, our memory summarization, our stateful langraph benchmark data, and then the new skill that state mechanism and our new method outperforms everything.
Speaker A
So not bad, not bad. Let's come to the insights. Take a step back. What what is it? In essence, what is the primary idea? Skill state is a runtime architecture that replaces now our append-only conversational history with some
Speaker A
explicit structured execution state that is valued, that is true at a very particular time, at a very particular number of steps during this execution.
Speaker A
And if you have seen my last video where we talked about a skill compiler, Wiki skill.
Speaker A
And I told you here the essence here, Wiki skill, what a coincidence, also by Google, is an external skill compiler.
Speaker A
The essence of this video is that skill state as presented by Google is now an external skill runtime.
Speaker A
I know this is not a coincidence because I selected those paper especially for this representation here, for this interconnect.
Speaker A
But let's come back to the agent. Remember the core LLM and the harness complexity. So this means that at every step on the procedure, the LLM, the core of the agent, decides which consequences of the newest observation deserve to survive in the
Speaker A
state representation in the complexity of the state space itself. It is the LLM that decides.
Speaker A
No harness complexity will solve anything here. So, this means what is the importance of the LLM because a lot of questions I receive from my viewers is, "Okay, so it moves everything moves to the harness." No.
Speaker A
Some dedicated task file system requirements move to the harness. The LLM, the neural network, the transformer architecture. This is where the real complexity, the real logic, the real reasoning, the decision making is.
Speaker A
So, what does the newest observation mean is a question that has to be answered by the LLM, not the harness.
Speaker A
Which fact from this new observation matter later in my decision process is answered by the LLM, not the harness.
Speaker A
What values should change now? What history elements are not relevant to further keep in the pipeline here for my decision-making process? The LLM will answer this.
Speaker A
And then you see, "And what is now in the harness?" The harness answers a different question. The harness answer is this new patch as decided by the LLM now structurally, let's call it legal, allowed.
Speaker A
This is here, you see, the deterministic functionality of the harness around pure genius, hallucinating, and probabilistic decision-making of the LLM.
Speaker A
And you know, I always have limitation because we have to be aware what are the limitation of this methodology. And you know, this is not in the publication in the paper. This is just my reflection.
Speaker A
I think the skill state central risk element, if you look at it, it just replaces here the long context of errors with potentially theoretically some state projection errors.
Speaker A
So, be extremely careful if you have new queries, new task, new complex task. Yes, you can absolutely do this if you have a linear logical chain to reduce the complexity. I think this new methodology skills that is just
Speaker A
beautiful to implement. But if you go to pure science, pure research to an almost infinite um theoretical space, what could happen?
Speaker A
Then you have to watch out for state projection errors and the real understanding here of all the experimental data that are now combined and understood and are pattern matching and pattern searched for by the LLM itself.
Speaker A
Okay, great. So, two new publication by Google. I waited for them. I combined them because I just wanted to show you how beautiful it is and how simple it is to come up with new ideas and how to combine here the wiki skill
Speaker A
from my last video with this skill state idea as shown in this particular video.
Speaker A
I hope you had a little bit of fun, some new information, something you want to try out yourself. Maybe you want to read the paper, which I highly recommend. It would be great and I see you in my next
Speaker A
video.
Topics:skill stateAI agentlarge language modelstate transitionLangGraphlong-horizon tasksconversational historystructured statePurdue UniversityAI workflow
