About 35 times lower median latency. $0.042 per million input tokens. No output-token charge. These are the numbers that caught my attention in Microsoft’s Decision-1 announcement. Its benchmark comparison puts median latency at approximately 85 milliseconds for MD1 against 3,010 milliseconds for GPT-6 Sol. (1)
For telecom, the interesting question is what those numbers let us build. In network operations, an application may need to interpret equipment logs, establish whether customers are affected and choose an approved response while the situation is developing. In customer care, it may need to recognise a service complaint and an explicit cancellation threat in the same message, then route the case with the right priority. Both involve understanding changing, often untidy information and making a decision the business has already defined.
Microsoft Decision-1, or MD1, gives us another way to handle that work. The application supplies the context, decision criteria and permitted answers, and MD1 scores those answers in a single pass. The result is numerical and ready for software to use.(1 5)
That design also helps explain the economics. Microsoft built MD1 by post-training Qwen3.5-9B, a 9-billion-parameter model, for decision scoring. It processes the input and returns compact scores, without generating a prose answer or a long reasoning trace token by token. Microsoft prices that service at $0.042 per million input tokens, with outputs free.1 Scoring a bounded set of answers avoids the repeated token generation that can make a reasoning-model response expensive.
For perspective, standard API output prices are $50 per million tokens for GPT-6 Astra, $50 for Claude Fable 5.1, and $20 for Claude Opus 5.5.2 3 Those models can earn their place when an incident needs investigation or a recovery plan needs careful thought. The architecture question is which decisions need a reasoning model, and which can go straight to MD1?
How the football demonstration brings the architecture to life
Artur Zielinski’s football match engine makes this easy to understand. Twenty-two players respond to a live game, choosing whether to pass, shoot, press an opponent or move into space. MD1 handles those immediate choices, using the match state, each player’s situation and the team’s current tactics. The demonstrator reaches 22 player decisions per second, with median decision times around 250 milliseconds.(4)
The two coaches operate on a different clock. A Luna reasoning model reviews the match and decides whether the team should change its formation, pressing or tempo. The documented football loop reviews every 30 match seconds, also reacting to events such as a goal, half-time or an opponent gaining control. After a tactical change, a cooldown gives the plan time to work. The revised tactics become part of the context for the players’ next MD1 decisions.8
This is how the game keeps moving while its strategy evolves. The model does not have to reconsider the whole team’s approach every time a player receives the ball. At 44:29 on the match clock, the demonstration’s running model-cost counter is $0.060. The dashboard’s cost accounting includes the decision and coaching layers.(4 8)
What the match looks like. Watching it play out, the effect is striking. The players never pause: passes, runs and challenges follow one another at the pace of a real game. Every so often the coaches step in, tighten the press or change the formation, and within seconds the players’ choices start to reflect the new plan. Fast decisions and slow strategy run side by side, each on its own clock.
Credit to Artur Zielinski and the Microsoft GBB team for the football engine. Artur’s original post and the think-slow-act-fast project are well worth exploring.
What appeals to me is how naturally the work is divided. Frequent decisions follow the current plan, while the reasoning model considers whether that plan should change. Telecom has workflows that fit this pattern, alongside others where the policy is already clear and MD1 can handle the decision without a reasoning layer.
How a decision model turns context into an actionable result
An MD1 request starts with a state, which is the evidence to evaluate, supplied as text or JSON. It can include unstructured logs or a customer message together with relevant business context. The application sends that state alongside preconfigured questions, instructions and answer criteria; several questions can travel in one API call.(5)

MD1 evaluates the evidence against those criteria and assigns probability to the allowed answers. For a choice, software can check the probability of the selected option before proceeding. A score expresses position on the supplied scale. Any separate API confidence field is distinct from an option’s probability; the workflow should be explicit about which value its policy checks.(5 7)

The harness turns the result into an action. This surrounding code and configuration checks thresholds, confirms that the evidence is still current, validates permissions and calls the appropriate tool. The questions and possible actions are configured in advance, so the workflow runs automatically as fresh context arrives.
A focused input and a compact numerical response keep the inference task small, and single-pass scoring avoids generating an explanation for every decision. The model still processes the context we send it, so assembling relevant evidence remains part of good engineering.
AT&T’s work provides a useful telecom example of this approach. Farbod Tavakkoli and Mark Austin have shared their OTel-2.0-Decision model, an open-weight model supporting classification, yes/no questions and ordered levels, with decisions read from answer-label probabilities. In this announcement, the team describes transcript classification as a high-volume application, alongside earlier work on a separate classifier for network root-cause analysis. Credit to Farbod, Mark and the AT&T team for sharing their models and implementation work with the industry.
For operators, this also expands the deployment choices. A managed decision service such as MD1 can be evaluated alongside an open-weight model that the operator hosts and operates itself. The choice will depend on accuracy for the task, latency, workload volume and the cost of running the service. In either case, the harness still needs to supply relevant telecom context, define the permitted answers and check the result before taking action. This is why the surrounding architecture matters: it gives operators a practical way to evaluate new decision models within workflows they have already built.
Applying decision models to telecom operations
Much of a telecom workflow consists of repeated judgements against an established operating policy. Logs vary, customers express the same problem differently, and service context changes, but the available destinations or approved responses are often limited. MD1 could make those judgements economical enough to run as the workflow unfolds, with a reasoning model available when the situation needs a new diagnosis or plan. I would start with decisions whose inputs, permitted actions and outcomes the operator can already describe clearly.
Responding to a deteriorating backhaul connection in the OSS
Consider two cell sites whose primary backhaul connection is deteriorating. The link remains up, but equipment logs show rising transmission errors, queues are building and voice and data services are suffering. A link-down alarm alone would not describe what customers are experiencing.
The OSS needs to connect those signals to the affected equipment, the sites it serves and the services that depend on it. This is where the network ontology matters. It provides the relationships that turn separate observations into useful context. My colleague Alberto Manuel explains this well in The Case for an Ontology Layer in Telecoms. I would recommend it to anyone looking at how agents can work more reliably with telecom data. (6)
Once the events have been correlated, the state (the input to the decision engine) combines the relevant log bundle, service impact and the facts about an alternative route:
Backhaul A: link UP, CRC errors rising and sustained degradation. Sites 047 and 048: voice and data impaired; queue building. Route B: healthy and approved, with projected load of 62% against an 80% operating limit.
The incoming state is evaluated against three questions already configured in the MD1 request:

The severity value follows from the ordered levels: 0 × 0% + 1 × 2% + 2 × 11% + 3 × 87% = 2.85. It is a priority signal against this operating rubric, rather than a percentage confidence. (5)
The harness checks impact probability against 0.95, the Route B choice against 0.90, and severity against 2.50. With those checks satisfied, it confirms that B remains approved and has sufficient capacity, then asks the network controller to apply it. MD1 selects an operating response; the controller executes the reroute. As traffic moves to B, the queue drains and calls and data recover.
Picture it on the operations console. CRC errors climb on Backhaul A. Alarms from Sites 047 and 048 are correlated into a single incident. MD1 returns its three answers in about a quarter of a second, the harness checks them against its thresholds and the capacity of Route B, and the controller moves the traffic. Moments later the queue drains and both sites recover. No engineer has had to assemble the evidence by hand, and every step leaves a record that can be audited afterwards.
The walkthrough uses a 250 ms response-time assumption and a 1,200-input-token request budget. At the published MD1 rate, that request costs $0.0000504, with no output-token charge. These are the assumptions behind the walkthrough.
This is an MD1-only application when recovery options and policy are established. Existing network protection mechanisms continue to handle their own time-critical functions; the OSS layer interprets incident evidence and selects among responses the operator has prepared. If the evidence conflicts or no suitable alternative exists, escalation is an explicit option.
Routing service complaints with the right customer context
On the BSS and customer-care side, a customer might write through an app, SMS or web form:
My data connection is crawling at 0.5 Mbps in central London, and I pay for 5G premium. Fix this or I’m cancelling.
The application needs to preserve both parts of that message: the network-performance problem and the expressed intention to cancel. Two preconfigured questions can make that distinction in the same request.

With a cancellation-intent threshold of 0.85, the workflow routes the case to priority technical support, attaches the original complaint and adds a retention flag. The 0.91 result identifies cancellation language in the message; predicting whether the customer will actually leave would need account history and a different decision task.
A reasoning model is unnecessary in this routing step because the policy and destinations are known. Investigation can follow with the technical team, with the reason for priority preserved in the handoff.
Artur’s telephone demonstrator takes the same idea into a conversation. MD1 evaluates partial speech for a permitted human handoff, while application code checks whether the transfer can proceed. Once it can, the application plays an approved acknowledgement and skips the final generated reply. In Artur’s example, the acknowledgement becomes ready 7.81 seconds into a 9.4-second utterance, so the handoff can begin before the caller finishes. (7)
For the caller, the difference is small but noticeable. Instead of finishing a sentence, waiting while the system composes a reply and only then hearing that they will be transferred, they hear a short, approved acknowledgement as they stop speaking, with the handoff already under way. The pause at one of the most frustrating moments of a service call simply disappears.
Credit to Artur Zielinski and the Microsoft GBB team. The early-handoff guide explains the partial-speech decision and application-controlled transfer.
When a reasoning model should join the workflow
Now imagine several backhaul incidents appearing together, with evidence that does not agree. A recent software change, a shared transport dependency and equipment faults are all plausible explanations. The operator needs an investigation that can gather evidence, compare explanations and revise the recovery plan.
A reasoning model can work across topology, change records and diagnostic results to develop that plan. The harness makes the approved plan and its permitted next steps available to MD1. As fresh event bundles arrive, MD1 can decide whether to attach them to the existing incident, request the next approved diagnostic or escalate because the evidence no longer supports the working diagnosis.
That is the hybrid pattern: a reasoning model develops or revises the plan, while MD1 handles frequent, bounded decisions within it. The reasoning model returns when a review is due or new evidence warrants a rethink. This is the relationship between coaches and players on the football pitch, applied to network operations.
Opportunities across the telecom business
The strongest candidates combine a high volume of varied inputs with a limited set of meaningful decisions. This matters in B2B sales as much as in operations: a stream of market signals can be screened for relevance without asking a reasoning model to develop an account strategy for every item. I would choose the architecture for each decision step, using these workflows as starting points.

For B2B qualification, the operator might define relevance as a potential need for managed connectivity, private networks or cloud interconnection. A new-site announcement could be relevant; an unrelated corporate announcement might not be. MD1 classifies against those criteria, and the sales workflow decides which qualified signals deserve further research.
The common requirement is a contextual judgement with clearly defined possible answers. Where a deterministic rule already answers the question reliably, the harness can continue using it. MD1 is useful when interpreting the evidence is the part that makes a simple rule difficult.
Keeping the architecture in the harness as models evolve
This brings me back to harness engineering: the code and configuration around the models that make the system useful. The harness assembles context, holds the decision criteria, checks thresholds and permissions, invokes tools and records what happened. It also decides when to involve a reasoning model or a person.

In the backhaul example, the harness connects inventory, service impact, route eligibility and the network controller. In customer care, it connects the message, account context, routing policy and available queues. Those integrations and policies should keep their value as the models improve.
A faster decision model can be evaluated against the same labelled incidents. A stronger reasoning model can take over investigation while the tools, permissions and service workflow continue to work. The operator can adopt a better model after evaluation without discarding the system it has already delivered.
That is how I would measure flexibility and innovation here: how quickly can we introduce a better model and improve an operating outcome? Alongside model latency and inference spend, I would track time to the right team, missed incidents, recovery time, customer resolution and the effort required to introduce the next model.
Understanding the cost of each architecture
At Microsoft’s announced price, one million routine decisions using 400 effective input tokens each cost $16.80 in MD1 inference. A workflow with an established policy may need no other model calls. The richer backhaul request uses a separate 1,200-token budget; the web companion calculator starts with a smaller routine decision so that each assumption is visible.
For the hybrid example, add 10,000 planning reviews and 20,000 escalations to those one million decisions. At the selected rates and token budgets, planning costs $120, escalations cost $90, and the total becomes $226.80. Using the comparison model for every routine decision costs $900. That makes the hybrid inference bill 74.8% lower under these assumptions.

Calculation inputs: 400 input tokens per routine decision; comparison model $2/M input and $10/M output, returning 10 output tokens per routine decision. Planning: 10,000 calls at 4,000 input / 400 output tokens. Escalation: 20,000 calls at 1,500 input / 150 output tokens. Comparison rates are adjustable assumptions, separate from the named models in the introduction. Equal effective batching; no cache discounts. Infrastructure, retrieval, speech, tools, retries and integration are outside this inference calculation.
If escalations rise to 20%, the hybrid total becomes $1,036.80. That tells us something useful about the design: a workflow that repeatedly needs a second investigation may be better served by a different split of work. The web companion calculator lets us examine that decision before choosing an architecture.
What interests me about Microsoft Decision-1 is the room it creates to improve an existing service. We can make a recurring judgement faster and cheaper, call on deeper reasoning when the situation needs it, and retain the telecom context and integrations we have already built. With those decisions held in the harness, each new model becomes something we can evaluate and adopt against a business outcome.
Sources and demonstrations
1. Microsoft Decision-1 announcement, 9 October 2026. Model basis, benchmark comparison and MD1 pricing. The latency figures describe Microsoft’s published comparison; MD1’s median is measured through Foundry in the same region.
2. OpenAI GPT-6 Astra pricing. Standard API output rate for the regular context tier.
3. Anthropic model pricing. Claude Fable 5.1 and Opus 5.5 standard API rates. Prices checked 15 October 2026.
4. Artur Zielinski’s football-engine post. Player throughput, latency and running cost from the MD1 demonstration recording. The six-cent figure is partway through the match.
5. Microsoft Learn: Decision-1 API and question types.
6. Alberto Manuel: The Case for an Ontology Layer in Telecoms, 16 June 2026.
7. Microsoft GBB: early human handoff. The example uses the 7.81-second readiness point; the guide distinguishes readiness, playback and adviser connection.
8. Microsoft GBB: football reference and planner loop. Review cadence is in match seconds; the documented change cooldown is eight match minutes.
Football and telephone demonstrations by Artur Zielinski, Microsoft GBB, described from the recordings he shared. Telecom walkthrough response-time and token assumptions are stated with the scenario; its cost is calculated from the published MD1 input rate.
This article was first published on LinkedIn on October 15, 2026.















