During the past few months, I have had the opportunity to dip into the APIs' synthetic process and backup programs for use by llms, especially agents using MCP Protocol. Initially, I expected that experience is not like any of the projects that the same improves I have made in the past. I was impressed, however, that these representatives are a new relative. As a result, the Apis appears to express the highest number of agent communication requires more than simply making them accessible.
This post is the result of my exam and field inspections, hopefully it can be useful for other experts.
Power and the curse of independence
We are enhanced by the third party tools and automated procedures that communicate with the Application API. Our site therefore appeared around the best of the best supports of the trials. Transactic, transition, contracted apis, which has the idea of compeling / backward and undertaken. This is all important concerns that are very important and often not working when processing an independent user.
With the agents as customers, there is no need to worry about back / transmission as each time cannot be counted and different. The model will learn how to use the tools every time they find them, arrive with the correct API telecommunications to achieve its purpose. As an enthusiasm as this agendary is possible again, you will also offer after a few failed attempts without being given reasonable motives and guidelines.
Most importantly, without such tracks can be successful by the API but fail to fulfill its goals. Unlike the symbolic events or experienced developers, it has only API answers to continue to make how they meet its purposes. The powerful kind of response is a blessing and curse as these two sources is also the money that can find it to work.
APIs Conducted to Conversations
I saw the first time that agent would need a different form of shape while solving some cases where an agent could not find the results you want. I have given MCP tools to the API that offers details of using any functional activity based on tracking data. Sometimes it looked like a agent was not just working well. When you look closely on communication, it seemed that the model was expensive and for different reasons received an empty list as an answer. This behavior can be 100% worthy of the same functionality in our API.
The agent, however, had trouble understanding why this happened. After trying a few simple differences, it gave and decided to move on other ways to test. To me, the communication has shown a missing opportunity. No one was wrong; Transactions, behavior was right. All relevant trials will pass, but measuring the performance of the API, we received 'the amount of success' was very low.
The solution turned simple, instead of bringing an empty response, deciding to provide multiple detail instructions and documents:
var emptyResult = new NoDataFoundResponse()
{
Message = @"There was no info found based on the criteria sent.
This could mean that the code is not called, or that it is not manually instrumented
using OTEL annotations.",
SuggestedNextSteps = @"Suggested steps:
1. Search for endpoints (http, consumers, jobs etc.) that use this function.
Endpoints are usually automatically instrumented with OTEL spans by the
libraries using them.
2. Try calling this tool using the method and class of the endpoint
itself or use the GetTraceForEndpoint tool with the endpoint route.
3. Suggest manual instrumentation for the specific method depending on the language used in the project
and the current style of instrumentation used (annotations, code etc.)"
};Instead of returning the results to the agent, I was trying to do something that often tried and – keep the conversation on. So my ideas of API answers, changed. When Illms are eaten, more than work goals, in fact, a Return immediately. The end of the end is the end, however, any returning data back to the agent has given you the opportunity to pull another string to its investigation process.
Handoas, 'Choose your own Aparture' apis
I think of the philosophy of this approach, I realized that something is common about it. Long ago, when I took the first steps to modern school APIs, I was introduced to Hyrmedia Apis and Toteas, a hypertex headquarters as an app. The idea is explained by the highest Seminalian Apis 2, Blog Past API must be hypertect-driven. One sentence in what the post hit my mind at the time:
“The transformation of the application must be conducted with the existing server's existing server options in the prescribed representations”
In other words, the server can preach The client should submit next rather than simply to send the requested data. The Calonical example is an easy application to get some resources, where the answer provides information about the client that can take next to that resource. API of showing them when the client didn't have to know anything about it before the one time in one place to enter where the selection branch appeared. Here is a good example from the Wikipedia page:
HTTP/1.1 200 OK
{
"account": {
"account_number": 12345,
"balance": {
"currency": "usd",
"value": 100.00
},
"links": {
"deposits": "/accounts/12345/deposits",
"withdrawals": "/accounts/12345/withdrawals",
"transfers": "/accounts/12345/transfers",
"close-requests": "/accounts/12345/close-requests"
}
}
}At that time, I was impressed with this sense, which reminded me of what is commonly called 'Choose your adventure books or' Ge-Game 'books. This type of books, a divorced part of my miscarriage, has not just passed the story (or give an API response to this template), but also provided the reader that the next set set of the following set set of the future set is received. Hypermia Rest apis hypocritical and provided users how to understand the app's status and operations available for each business or process without reading comprehensive documents.
Hypermedia on steroids
One way to look at Hypermedia API is that they provide additional context as part of the answer. The context, in agents, are everything, and certainly do not need to quit in choices or performance available. API is a point of social networking and provided in a form that will promote additional interaction. Let's look at another example!
Another tool I worked in, allows the model to return Appeal Problems Available in the submission area, and based on the recognition details. A direct result of the speedy response, was Anomaly found to make a measure of conclusion. It seems that sometimes the answers Too slowly, ~ 70x slightly than median. Giving that a piece of information in the LLM was helpful, but eventually did not fulfill more than the simple repetition of the information provided.
For a query, here is the answer provided, as well as an agent exit:
{
"Name": "Performance Anomaly",
"Category": "Performance",
"P50":
{
"Value": 12.33,
"Unit": "ms",
"Raw": 12331700.0
},
"P95":
{
"Value": 909.62,
"Unit": "ms",
"Raw": 909625000.0
},
"SlowerByPercentage": 7376.314701136097,
"SpanInfo":
{
....
},
#more data
....
}
There is nothing wrong with an API response or how the user was delayed by the agent. The only problem is a lot of context and lost ideas that would withstand the agent's ability to take the conversation forward. In other words, this is a native of the traditional API, but agents in consultation are very effective. Let's see what happens if we change our API to inject extra status and the suggestion to try to carry a forward experience:
{
"_recommendation":
"This asset's P95 (slowest 5%) duration is disproportionally slow
compared to the median to an excessive degree
Here are some suggested investigative next steps to get to the
root cause or correct the issue:
1. The issue includes example traces for both the P95 and median
duration, get both traces and compare them find out which asset
or assets are the ones that are abnormally slow sometimes
2. Check the performance graphs for this asset P95 and see if there
has been a change recently, if so check for pull requests
merged around that time that may be relevan tot his area
3. Check for fruther clues in the slow traces, for example maybe
ALL spans of the same type are slow at that time period indicating
a systematic issue"
"Name": "Performance Anomaly",
"Category": "Performance",
"P50":
{
...
},
#more dataEverything we've done provides more AI model to continue. Instead of returning just the result, we can feed the model with ideas on how to use the information provided to. Of course, these suggestions are used immediately. In this regard, the agent continues to investigate the problem by calling other instruments to assess the ethical method, compare the track and understand the problem list:
For new information in the area, the agent delights to continue the test, check the timeline and combine the effects of various tools until the new response rate:
Wait … Shouldn't all the APIs create such?
Certainly! I definitally believe this approach can benefit users, Developing people, and everyone – even if they use the brain of consultation rather than llm models. In short, API driven by negotiations can increase the context more than a data and place of opportunity. Opening many branches for testing agents and users equally and to improve the performance of APIs in resolving basic use case.
There is a greater chance of evolution. For example, plans and ideas given for the client with API in our example, what if they are done well? There are many different A2A models out there, but sometimes, it can be a back-up program and to promote client appearance about what information means and what can be done better. As for the user? Forget about him, talk to his agel.
