The decision-model API pitch, and the name that is missing
The interesting part of working with a language model stopped being the paragraph it writes back. It is the moment an agent decides to do something: choose a tool, pass arguments, stop talking and act. A decision-model API is an attempt to agree on what that exchange looks like on the wire, so an agent can ask any model for an action in roughly the same shape. AWS, Upstage and Ollama are named as backers of that idea, according to The New Stack (opens in new tab). OpenAI is not on the list.
Reading the three names as a coalition is easy enough. AWS brings the distribution, mostly through Bedrock and the enterprise accounts that already buy compute there. Upstage brings a model vendor that is not OpenAI, which matters in places where procurement has opinions about which vendor’s weights sit under the workload. Ollama brings a runtime that is installed on a large number of developer laptops and a smaller number of production boxes. On paper that covers cloud, model and local.
The name that is missing carries more weight than the three that are present. Tool calling as it works today was shaped by OpenAI’s API schema. Nearly every other vendor’s format is a near copy of it, down to the tools array with a type field and a nested function object holding the name and a JSON Schema for parameters. Agents running in production right now speak that dialect, because that is what developers wrote against. A standard the dominant vendor has not signed onto is either the start of a real alternative or a document with three logos and no porting effort behind it. Nothing in the announcement settles which.
I am going to stay close to what has actually been published, and that is not much. There is no pricing, no description of what data crosses the boundary during a decision call, no throughput figures, and no statement about who governs the schema or how it gets versioned. Those are the details that determine whether this is something you can build on, and they have not been shared. What follows treats the agreement as a signal worth tracking rather than a migration you should plan.
Before getting into what it might change, it helps to see how the current arrangement came about, because the decision layer was never designed. It accumulated.
Background: how the decision-model API discussion got here
The gap between a model that writes and a model that acts is wider than it looks from a demo. Asking for a paragraph and getting one is a solved problem. Asking an agent to pick the right action from a set of options, in a format your code can branch on without a regex, is a different problem that arrived after the fact.
Function calling filled that gap by accident. When the first tool-calling APIs shipped, the pattern that stuck was a tools array passed alongside the message, with each entry naming a function and describing its parameters as JSON Schema. That was meant as a convenience for retrieving structured arguments. It became the interface. By the time anyone thought to standardise it, thousands of agents were already parsing the same shape, and the shape belonged to one vendor’s API.
Then every other provider shipped a near copy. The field names drifted by a character here, the location of the arguments object moved there, and a string-encoded arguments blob in one SDK showed up as a proper JSON object in another. None of those differences break a single-vendor deployment, which is why they survive. They break the moment you want to move. I have watched teams keep two parallel tool-definition files because their hosted judge model and their self-hosted agent ran on different schemas, and nothing in either vendor’s docs acknowledged the other existed.
Ollama changed the economics of that decision more than the technicals. Once a laptop could serve a capable model behind a plain HTTP endpoint, the weights stopped being the lock-in. You could pull a model in a few minutes and start testing against it. The remaining friction was not inference, it was everything around it: the schema your code must match, the endpoint shape, the way you serialise results. The model became portable and the decision format became the thing holding the workflow in place.
That is the ground the new agreement is standing on. The New Stack’s report on the three-party decision-model pact (opens in new tab) frames it as a move to standardise how an agent requests and receives a decision, separate from whatever text the model produces alongside it. Which is a useful thing to standardise, and an awkward one, because the de facto version already exists and nobody formally agreed to it.
What’s happening now: the AWS, Upstage and Ollama agreement
Three names are attached to this. AWS, Upstage and Ollama have agreed on a decision-model API, per The New Stack’s report (opens in new tab), and the framing is that an agent submits a choice and receives a structured decision back, kept separate from whatever free-text reasoning the model produces around it.
What that buys, in plain terms, is a contract. “Pick tool X with these arguments” stops being a string you scrape out of a chat completion and becomes a shape the runtime knows how to validate. Say you run a small storefront and your agent decides whether to refund an order or open a dispute. That decision is the part your code acts on. The paragraph explaining why is fine for your logs and useless to your billing system.
The three backers cover different ground. AWS brings distribution and the hosted endpoints most people will actually call. Upstage is a model vendor, so at least one party has an interest in the schema being expressive enough to be worth implementing properly. Ollama is a local runtime, and its name on the list is the one I find most telling, because it suggests the format is meant to be spoken on a box you own rather than only on someone else’s API.
OpenAI’s signature is the one missing, and that absence carries more weight than the three names present. Most agents running in production today were written against OpenAI’s function-calling schema or a close copy of it. A standard that excludes the vendor your code already targets has two possible futures. It becomes a genuine alternative that people write ports for, or it becomes a small ecosystem with a spec document, courteous support and no traffic. Adoption does not get announced. It gets observed, in package download counts and in the number of servers that actually speak the thing.
What I can run today is nothing, and I want to be blunt about that. I have not seen a versioned spec, a reference server, or a compatibility test suite. The announcement names supporters. It does not ship an artifact. I would not plan a migration around a headline, and I would be wary of anyone who tells you to start one.
What the decision-model API means in practice
The thing an interoperability layer actually removes is not the model call. Calling a model is a POST request either way. The cost sits in the tool definitions, those JSON schemas describing what your agent is allowed to do and what arguments each action accepts. I have the same search_orders schema duplicated across four files in one project, once for the hosted provider, once for the local box, and twice more inside eval scripts that drifted out of sync months ago.
Think about what a site owner goes through moving a WooCommerce store to a new host and a new payment gateway at the same time. The product data moves cleanly. The card fields do not. One gateway calls it billing_address_1, the next calls it address_line1, and every checkout template has to be edited by hand. That is the shape of the problem. A decision-model API is a field-name agreement, and its whole value is measured by how many of those handlers you delete.
Local serving matters here in three concrete places. Development machines, where you want a tool-calling loop that runs without a network round trip and without burning credit on a schema typo. Air-gapped environments, where the hosted endpoint is simply not reachable and never will be. And workloads where per-token billing is what kills the project, which is a different constraint from latency. I have run support triage on a small quantised model for exactly that reason, not because it was fast.
What no spec fixes is everything around the call. State between decisions, because your agent rarely makes one choice in isolation. Retry semantics, because a decision that times out mid-execution leaves you guessing whether the tool ran. And accountability. If the agent picks refund_order when it meant cancel_order, no format on earth absorbs that. The schema describes the choice. It does not own the consequence, and your support inbox will.
Evaluation is where I am genuinely split. A portable decision record makes it trivial to run three models against the same task and compare chosen tools and arguments directly, which is real progress. It also makes it easy to swap a model out in an afternoon and ship it without re-running the tests you wrote for the old one. Convenience and rigour pull in opposite directions, and the standard will make the convenient path faster.
What to expect next
The thing that would move this from announcement to infrastructure is genuinely boring: a versioned specification document with a date on it, and a reference server you can pull and run. Until those two artifacts exist, every headline about AWS, Upstage and Ollama agreeing on a decision-model API is a press release with a logo wall, and I have watched enough consortium launches to know the pattern. Three blog posts, a landing page with an email capture box, then eight months of silence. The efforts that survive publish the grammar first and the marketing second.
So I would watch the spec repository rather than the roadmap. What I want to see is whether the decision schema is versioned, whether deprecation is handled, and whether a decision record has a defined shape on disk. If the answer to any of those is “we will figure that out with the community,” read that as a sign the hard parts were not settled before the announcement, which is normal, but worth pricing into your timeline.
Two other signals matter to me. First, whether other model vendors sign on, because a standard with three backers and no fourth is a club. Second, whether Ollama’s involvement stays at the runtime layer, meaning it serves models that speak the format, or extends into actually defining the schema. Those are very different levels of commitment, and a runtime vendor shaping a decision format has more influence over what your tool definitions look like than a cloud vendor does.
The commercial questions are the ones nobody has answered yet. How AWS prices access to a decision endpoint, what data crosses the boundary during a call, and whether “compatible” ends up meaning one thing in an AWS doc and something slightly different in Upstage’s. That last one is how these standards quietly fork. The New Stack’s write-up notes OpenAI’s absence, and I think that detail will matter more in a year than the three names that are on the masthead.
My own uncertainty is real and I will not paper over it. A three-party agreement tells you nothing about behaviour under load, nothing about how the format handles a decision that arrives malformed, and nothing about latency once a hosted endpoint is in the path. Running it in a demo with a small tool list is not evidence. I would want to see someone push a few hundred concurrent agent loops through it before I let it near customer traffic, and I doubt that will be the first thing published.
A concrete next step
You can build the useful half of this today, before a spec exists, and it costs you an afternoon.
Start with a small tool-calling model on your own machine. ollama pull llama3.1 or qwen2.5:7b will do, since both handle tool schemas without much coaxing. Then run it behind Ollama’s OpenAI-compatible endpoint, which listens on http://localhost:11434/v1 by default. That one detail is the reason this exercise is worth doing. Your agent code talks the same shape it would talk to a hosted provider, so when a decision-model API does show up, you are swapping a base URL and a schema, not rewriting the loop.
Then instrument the loop properly. Every time your agent picks a tool, write a record: the tool name, the arguments it passed, whether you asked for a confidence score and what came back, how long the call took, and what happened after. Whether the run succeeded or the tool returned an error. Keep that log in your own format, in your own database, under your own retention rules.
A portable decision record is worth more than a portable decision API. If you have six months of records showing which model picks which tool on your actual traffic, you can evaluate any incoming standard against evidence instead of a press release. Without those records you are back to vibes, and every vendor’s comparison chart will look equally convincing. A shop owner watching a support bot refund the wrong order will tell you the argument ends when you can point at the log line.
The last thing, and it takes ten minutes. Grep your repositories for your tool definitions. Count how many copies of the same JSON schema you are maintaining across SDKs, prompt templates, and whatever wrapper you wrote two years ago. If the answer is one, this whole standards conversation is background reading for you. If the answer is four or more, and they have already drifted apart, then you are the person this announcement is aimed at, and standing up the local loop above is the cheapest way to find out whether it will actually help.