Anthropic killed Tool calling

The Only Bamboo
245 followers
24 Video Views·Mar 12, 2026
Full Step-by-step tutorial for Programmatic tool call setup: https://www.aibuilderclub.com/
🔗 Links
- Try Superdesign: http://superdesign.dev/
- Follow me on twitter: https://twitter.com/jasonzhou1993
⏱️ Timestamps
0:00 How things evolved
5:27 Programmatic tool call
9:10 Dynamic filtering
10:13 Tool search
12:15 Tool use example
AI Generated·May contain errors
So Entropiq has released a list of really interesting updates for the
agented tool calling that not a lot of people are talking about or pay
attention to, but I think it is a really big deal if you're building agents,
particularly for long running and complex tasks.
And this is what I want to talk you through today, what it is and
how can you apply to your agent.
So what Entropiq here has, I can almost consider as tool calling 2.0.
If you're not familiar with tool calling concept, tool calling
is this foundation of agents.
It transforms large-range model from outputting pure text to outputting
a specific JSON that can be used to invoke an API or functions.
So that enables large-range model to take actions in real world.
And the mechanism of tool calling or function calling hasn't been really
changed for the past two years.
Basically you will give large-range model a list of two definitions.
It has title, name, description, and most importantly, the parameters that
agents need to generate to run this function.
Then when user asking agent question, like what's the weather in Paris, it
will send both the user question to schema to the large-range model, which
will return a tool call text, looks something like this, where the model
decided to call get a weather function with parameter Paris.
Then on the server side, it will run the function with this specific
parameter, get a response, and then send all the previous message plus
this new tool response back to the model.
And in the end of the model, return a synthesized message.
So when you look at this process, it's actually kind of manual and basic,
but because everything is happening automatically, it feels kind of magical.
This is exactly what is happening when you message your
CloudBot and it is showing typing.
Behind the scenes is doing this ping pong round trip to decide what tool to
call, output the params, run the function, get a response back, decide the next step.
But this tool call concept we introduced two years ago also has
a lot of problems and limitations.
The biggest issue is efficiency.
So for more complex tasks where Adrian will run multiple different tools in a row,
we're basically purely relying on large-range model to generate
the parameters for each function.
And this can lead to some non-deterministic behavior as well as loads of
waste in the token context window.
And let's just take one basic example.
Let's say your agent has access to a list of Gmail related tools, and you
ask him, what are all the emails we have from Bob in my Gmail inbox?
What happened is, Adrian will first say you try to call the function
search email with parameters Bob, which you can return a list of different
email IDs, because that's how their API endpoint works.
Then to get each email, Adrian will need to run re-email tool with ID one,
then do it again for the other email ID, repeat multiple times
until it get all the information.
And here we are relying on large-range model to regenerate the ID exactly the same.
And also some of tool MCP, their response result is gigantic.
Like for the search email function, it will return us a huge amount of metadata
that we don't really need, even though we just need the ID to be
able to invoke the next function.
But all those information just stay and eat up our context window unnecessarily.
And this type of situation can get even worse in some other situation where the
function tool call parameter is actually complicated.
Let's say you give your agent a task to write a blog about AI news.
And you can run the web search first, which return a list of URL.
And for each URL, it will run the web fetch tool, which will return HTML
alongside a whole bunch of noise in the HTML as well.
And in the end, if you have a specialized tool to write blog where it will take
row content and output a well-written blog, then large-range model will need
to manually recreate all the row content from each web fetch function to pass
into this right blog tool.
And this is going to be very expensive and with a whole bunch of token unnecessarily.
And this problem is not going to be solved by just having model
with bigger context window.
Because even though today's modern model has a 1 million context window, the actual
effective context window is just somewhere between 128K to 200K.
So you almost always want to optimize what goes into the context window.
And this is what Entropiq's new advanced tool call release is so interesting.
They released a list of different improvements to its tool call capability
to solve exactly this problem.
And I will talk you through one by one.
Firstly, let's talk about programmatic tool calling.
This is one of the most important release here.
The main idea here is very similar to a paper called executable code actions.
So instead of using large-range model to be the glue to take a response from one
action passing to the next action, what if we can just give a model environment
where it can access any tools the agent has access to and just let large-range
model to output a piece of code to run multiple different functions.
It will know how to use code to passing the result from one function to the other.
It can even use things like for loop, conditional pass to achieve more
complicated workflow in a very deterministic and token efficient way.
And this paper was released when we were still on like GPT-4 era, but the
improvement of tool use was already significant and Cloudflare also had
something similar released last year called code mode.
They found that large-range model is much better at writing code rather than
outputting JSON like this for calling the tool.
So getting large-range model to perform tasks with tool calling is almost
putting Shakespeare through a month-long class in Mandarin and
then ask him to write a play.
So their point of view is that large-range model is just going to be so
much better at writing code rather than outputting JSON and reasoning
about it, deciding the next step.
So they also have code mode where it has function to convert any MCP to a
TypeScript so the agent can write a code to evoke those MCP tools.
And this entropic programmatic tool calling is exactly the same concept.
So instead of just getting model to run one tool call at a time, see the
response and decide to next action, they can just get a model have access
in an environment that have direct access to all the MCP tools.
Then the model can just write a piece of code like this to invoke those
MCP tools so that they can contain a whole bunch of noise and the context
within the function rather than exposed in the context window.
And in their experimentation, they compared two methods side-by-side to
get same model perform some puzzle resolving tasks, and you can see the
context window of programmatic tool call is so much smaller than the
traditional tool call.
And Ops 4.5 is able to proceed much further on this task completion
compared with the previous one.
And the way they designed this make it very easy for you to enable
programmatic tool calling in your existing agent setup without
restructuring the whole agent orchestration.
All you need to do is in your large model response, making sure you
include this code execution function.
So code execution function is a sandbox where agent were used
to write and execute the code.
Then for each tool that you pass into the large model, you can pass this
new parameter called allowed caller.
Pass this code execution 2026.0.1.2.0 as one of the callers here.
With this, the programmatic tool call is already automatically activated.
It will firstly return a response look like this.
So when you pass a large learning model, a function for query database
with a request, query customer purchase history from the last quarter and
identify the top five customers by revenue, large learning model will
firstly return a response of a piece of code that is written, and inside
this code, you can see it will try to call this function with certain
parameter as well as another one with tool use for this function and the
input parameter, so you can take out this response by filtering out all
tool use and caller to do the actual database query, and once finished,
you can send back all the past conversation history with a new
user message of tool response.
Then the large learning model will just take your new tool results, feeding
back to a piece of code written before, run it, get a response and synthesize
and in the end, get a final response back.
So the change on agent side is fairly minimum.
All you need to do is just adding this code execution tool alongside
a lot of caller parameter for the functions and update your agent
runtime to be able to extract those type of tool use, and this
comes with a bunch of benefits.
Because with code, large learning model can use for loop to just batch
processing tasks that can be ran in parallel, and you can also use
conditional loop to set up some more complex structure as well as some
deterministic filtering to making sure only relevant information are returned.
It fundamentally reduce all the model round trip to just minimum
amount of large learning model call.
So you can reduce 30 to 50% of token consumption and run agent much faster.
This is particularly good for use cases where you're processing large
data sets that are needing aggregations or fairly deterministic tool call
sequence that can be represented in code.
And if you're interested in learning more, we have this step-by-step examples
and tutorials in AI Builder Club about how it works and how you can set
things up properly for both programmatic tool call and all the other techniques
that we're going to talk about.
Meanwhile, we have course and content to cover AI coding, building
production agents, and a weekly workshop where industry experts and
myself will come and share the latest learnings of building
large learning model software.
And most importantly, we have this community of top AI builders who are
building and launching AI products now.
So if you want to follow and learn what myself and other builders are
reading and learning every day, this is a great place to be.
I put the link in the description below, so you can join if you're interested.
But yeah, this is the first part of programmatic tool call.
Next, let's talk about dynamic filtering for WebFetch.
Dynamic filtering is a subset feature of this programmatic tool call.
So Entropiq released the dynamic filtering capability for the WebFetch tool.
The problem you try to solve is that WebFetch tool traditionally dumps large
HTML page into cloud's context window.
But most of those HTML content is irrelevant, and this leads to a lot of
wasted token in cloud's context window and reduced accuracy.
What dynamic filtering do is that it will add a layer in the middle.
Instead of returning the full row HTML, it will run a code that
filter out only relevant content and extract only those relevant
ones into context window.
And from their testing, this dynamic filtering methods is able to reduce
on average 24% of token consumptions.
To activate it is also pretty straightforward.
You just need to making sure you're pointing to this special
version of WebFetch tool, 2026.0.2.0.9.
You will see in API response, you will automatically seeing those code
execution step happening in the middle to try only specific relevant keys.
So in the end, it will return back only the relevant content
back to large range model.
Meanwhile, Entropiq also introduced a tool search concept.
So the problem you try to solve is that the way agent use tools or
MCP is not really scalable.
Very easily it loads up context window in your agent, regardless whether this
tool is always needed or not.
And this doesn't feel very optimal.
And also why so many people are dropping the concept of MCP instead of moving
towards the skill plus CLI version, because it's just so much more token efficient.
However, agent skill is not a complete replacement for MCP because MCP also
comes with a lot of benefits, especially around the type safe, since large range
model will know exactly what the input schema is and will try to follow that
exact input schema, which you don't really get from the skill plus CLI easily.
That's why Entropiq released this tool search concept.
What that means is instead of loading up hundreds of tool schema into context
window, you just have one tool called tool search tool that can be used to
retrieve random tools, and that takes only around 500 tokens.
So for many scenarios, it can lead to up to around 80% of context window optimization.
And the way it works is that you can give your large range model call a tool search
tool, and then for each tool MCP, you can start setting this deferred loading data.
Once the deferred loading is true, then this tool won't be visible to the agent
at default.
Instead, large range model can use this tool search tool to retrieve the
information dynamically.
And in the large range model call response, you will just see some additional steps
show up in the middle where you will see it, it will try to invoke this tool.
And this works with MCP as well.
For the MCP server is actually very flexible.
You have this one config called default config.
And if you set deferred loading to be true, that means all the tools from this
MCP server default won't be visible, but you can set specific actions within
MCP like search events here to be deferred loading false, which means only this
specific function will be always visible.
So this is a really good method if your agent has more than 10 different tools or
MCPs and use this to significantly reduce the amount of token consumptions.
And lastly, tool use example.
So this is trying to solve another problem there.
For some of the complex tools, you will find large range model, even with MCP will
struggle to know how to use this tool.
Think about a tool you might have for customer support called create ticket.
It has many different properties that agent need to fill in.
And even though schema will clearly describe what kind of field need to be put
in, but it's not entirely clear how to fill in each field.
For example, for due date here, it's not clear which format you want agent to
output for due date.
And also there might be some correlation between one field to another, like in
this escalation, you might have different SLA hours depends on level field here.
And all those things can be probably achieved before by adding more description
and prompt to indicate how to use the tool.
But now they have more specific field for you to add in those information in
called input examples.
So when you define a tool, you can also pass in a array of examples of how this
tool will be called.
So it can be used as example for agent to follow.
And this is particularly useful for complex nested structure where valid JSON
doesn't imply the correct usage or your tools has many optional parameters and
larger learning model just keep forgetting or not building certain optional
parameters when it should.
In Entropi's own experimentation, using tool use example can improve accuracy
from 72% to 90% on complex parameter handling.
So those are a few new use cases and patterns Entropi released about tool
coding that I thought was really exciting and interesting.
And again, if you want to learn more, there are step-by-step tutorial in AI
Builder Club you can read and follow.
And every week we have weekly workshop to talk through those latest learnings
from both myself and industry experts.
And if you want to follow and learn what I'm reading every day about this
constant changing AI field, this is a great place to be in.
I put the link in the description below so you can join if you're interested.
I hope you enjoyed this video.
Thank you.
And I'll see you next time.
