OpenAI has recently released two capabilities that initially appear unrelated.
The first is the Decisions API, which turns text or images into a probability, a score or a selection from predefined options. Instead of asking a model to compose an answer, software can ask whether a condition is true, which category applies or how strongly an input satisfies a particular rubric.
The second is a significant improvement in models’ ability to work with programming languages such as COBOL, Fortran and Visual Basic. Much of the discussion has focused on the possibility of giving banks and other institutions a long-awaited coding makeover. Gizmodo described the opportunity as a bridge between a new generation of AI-assisted developers and the ageing software that still supports critical services. Gizmodo: Financial-sector coding makeover
One development concerns decisions. The other concerns code.
But both are moving AI towards the same valuable territory.
They are moving it into the business logic of the firm.
The important output may no longer be language
Most of the generative-AI market has been built around producing strings.
A model writes an email, summarizes a report, answers a question or generates code. Even when the output is structured, the underlying interaction usually begins with a model designed to generate language.
TypeSafe AI challenged that assumption when it introduced Jev in September.
Jev was presented as a “System One” model: unstructured information enters, and typed probabilistic decisions emerge. The model does not need to explain itself in prose or generate an open-ended response. It selects from an approved set of choices, evaluates a condition or assigns a score that ordinary software can use. TypeSafe AI: Introducing System One Models and Jev
OpenAI released its Decisions API several weeks later. The timing naturally made the launch appear to be an answer to Jev, although the more important development is that a major model provider validated the category almost immediately.
OpenAI’s API currently supports three basic decision types: predicates, choices and scores. It is designed to return these approximately ten times faster than the company’s general Responses API, using the smaller GPT-6 Luna model. It can classify documents, route requests, assess visible damage or prioritize issues without first generating and parsing a conventional natural-language response. OpenAI: Decisions API · OpenAI: API changelog
The interface may appear modest. Strategically, it is not.
It suggests that the AI industry is beginning to distinguish between two fundamentally different forms of intelligence.
One is intelligence intended to communicate with people.
The other is intelligence intended to operate inside software.
A customer may value nuance, explanation and conversational flexibility. A production system frequently needs something narrower: a permitted value, delivered quickly and consistently enough to determine what happens next.
The shift from generated answers to bounded decisions turns AI from content into control flow.
A decision API makes judgment composable
Software has always contained decisions.
If the amount exceeds a limit, request approval. If the transaction matches several conditions, flag it for review. If the customer belongs to a particular segment, offer one product rather than another.
Traditional systems express these decisions through explicit rules. The approach works well when every relevant condition can be described in advance.
It becomes brittle when the evidence is unstructured or the distinction depends on interpretation.
A complaints team may need to determine whether a message concerns billing, technical support or potential fraud. An insurance workflow may need to assess whether a photograph shows meaningful damage. A financial institution may need to decide whether a document satisfies a policy whose application depends on context rather than a single field.
Large language models can already perform these tasks. But using an open-ended generator for every small decision introduces unnecessary latency, cost and output variability. The response may need to be parsed and validated before another system can trust it.
Decision models narrow the output space in advance.
The surrounding software defines the available choices. The model evaluates the evidence. Code determines what each answer is allowed to trigger.
This does not make the system deterministic. It makes the uncertainty usable.
A business can set one threshold for automatic action, another for human review and a third for rejection. Different thresholds can reflect different consequences: the cost of sending a billing question to the wrong department is not the same as the cost of incorrectly clearing a suspicious payment.
OpenAI’s own guidance therefore recommends setting thresholds using labelled examples from the intended application and considering the relative cost of false positives and false negatives. OpenAI: Interpreting decision answers
The commercial opportunity is not simply faster classification.
It is the ability to insert machine judgment into places where companies previously had to choose between rigid rules and expensive human review.
Legacy code contains more than technical debt
The connection to OpenAI’s work on older programming languages becomes clearer when we consider what legacy systems actually contain.
A decades-old banking application is not merely old code.
It may contain thousands of decisions accumulated across years of products, policies, regulations, customer exceptions and operational experience.
Some of those decisions are documented. Others exist only in the software’s behaviour.
A particular decimal may be truncated rather than rounded. A missing record may cause one process to stop and another to continue. An account may be treated differently because of a condition introduced after an incident twenty years ago.
OpenAI’s COBOL migration evaluation is revealing for precisely this reason.
The task is not simply to translate syntax into C++, Java, Kotlin, Python or Rust. A successful migration must preserve the program’s observable behaviour. The evaluation uses hidden tests and requires byte-for-byte parity across outputs. OpenAI highlights rounding and missing-record handling as examples of apparently minor differences that can change financial results. OpenAI: Advancing coding in low-resource programming languages
GPT-6.1 Sol reportedly achieved 86.6% accuracy at low reasoning effort on the evaluation, rising to 97.9% at higher effort. OpenAI is explicit that applying these capabilities to production software still requires expert review and testing against the system’s actual business rules and dependencies. OpenAI: COBOL migration evaluation
That caveat points to the real difficulty.
The challenge of legacy modernization has never been rewriting every line of code. It is determining which behaviours are essential, which are accidental and which should no longer survive.
A faithful translation can preserve a defect as effectively as it preserves a valuable rule.
A cleaner system can also fail if it silently removes an exception on which customers, employees or downstream applications depend.
The scarce capability is not converting one language into another. It is recovering the institution’s intent from the system that currently expresses it.
AI can expose the operating model hidden inside the software
This creates a larger opportunity than a one-time code migration.
AI can help companies inspect a legacy estate and separate several things that have gradually become entangled:
- Stable business rules that should remain deterministic.
- Contextual judgments that may benefit from a decision model.
- Historical workarounds that should be redesigned.
- Regulatory controls that require explicit ownership and testing.
- Obsolete behaviour that should disappear during migration.
Once separated, these elements do not all need to return to the same monolithic application.
A calculation can remain conventional code. A policy boundary can become a configurable rule. An ambiguous document classification can be handled by a decision model. A high-consequence exception can be sent to a named reviewer.
The result is not simply newer software.
It is a more legible operating model.
This matters because legacy modernization projects often recreate the architecture they intended to replace. Teams translate the code, move it to newer infrastructure and discover that the organization is still constrained by the same tightly coupled logic.
AI makes code conversion faster. That should create room for more architectural judgment, not an excuse to avoid it.
Confidence is an input to governance, not a guarantee
Typed output is safer for software to consume than unrestricted prose. It does not mean the underlying decision is correct.
A model can always return a valid option and still select the wrong one.
That distinction is especially important when decisions are accompanied by probabilities or confidence scores. These values can help determine when a system should act or escalate, but they should not be interpreted as universal measures of truth.
Recent independent research on Jev illustrates the problem. One study found that apparently strong results could change when response options were reordered or irrelevant numerical information was introduced. Another found that decision models were strongest when the required evidence was already present, but could overstate probabilities and accumulate errors when individual decisions were combined into longer workflows. Research: A case study of Jev · Research: General Decision Models
These findings do not invalidate the category.
They clarify how it should be used.
Confidence must be calibrated against the company’s own data. Decisions must be tested in the context in which they will operate. A fast local decision should not be assumed to produce a reliable end-to-end process.
The surrounding architecture remains responsible for limiting what a decision can cause.
A low-risk classification may immediately route a document. A credit decision may require independent verification, deterministic controls and human authority. The model’s output can inform the process without becoming the entire process.
Finance reveals what is at stake
Financial services is an obvious proving ground because it combines legacy software with high volumes of consequential decisions.
Banks operate systems built across multiple technological eras. New digital experiences often sit above core applications whose behaviour has been refined over decades. The old system may be difficult to change, but it is also carrying institutional knowledge that the company cannot afford to lose.
At the same time, much of financial work consists of repeated judgment:
- Is this transaction unusual?
- Does this document satisfy the requirement?
- Which risk category applies?
- Does the case remain within policy, or should it be escalated?
Decision models can make these judgments cheaper and faster. Coding models can help expose and modernize the systems that act on them.
Together, they create the possibility of replacing a legacy application with a more modular decision architecture.
But they also create a concentration risk.
If the rules, interpretations and execution logic of the institution become inseparable from one model provider’s platform, the company may modernize its software while making its operating model less portable.
This is the strategic question beneath the technical progress.
A company must decide which parts of its decision process it is willing to rent and which parts it needs to own.
The new moat is an encoded decision system
Access to capable models will not remain a meaningful differentiator by itself.
The more durable advantage will come from how a company defines decisions around those models.
That includes the evidence considered, the options permitted, the thresholds applied, the exceptions recognized and the feedback used to improve performance.
Two institutions can call the same API and receive very different commercial results because one has expressed its operating knowledge more precisely.
This means decision architecture may become a valuable proprietary asset.
A company should be able to identify:
- What decision is being made.
- Which data may inform it.
- Who owns its definition.
- What the available outcomes mean.
- How uncertainty changes the workflow.
- Which tests establish acceptable performance.
- What happens when the model or policy changes.
- Whether another model can replace the current one without redesigning the process.
These are not simply governance questions.
They determine the quality, economics and portability of the product.
The firms that organise this knowledge well will be able to test new models quickly, automate more safely and modernize software without surrendering the judgment that made the original system valuable.
Those that do not may exchange one form of technical debt for another.
The model is becoming part of the institution
The first phase of enterprise AI largely helped people produce work.
The next phase will increasingly help software decide what work should happen.
OpenAI’s Decisions API is one sign of that transition. Its progress in legacy programming languages is another. One makes machine judgment easier to insert into applications. The other makes the systems containing decades of existing judgment easier to understand and change.
The combination is more consequential than either capability alone.
It means AI can begin to participate in the translation of institutional knowledge from an ageing system into a new operating architecture.
At BraidNest, we see this as an execution-layer problem.
The objective is not to place an AI model beside every decision or automatically translate every legacy application. It is to understand where the organization’s real logic lives, determine which parts should become rules, models or human judgments, and construct a system in which each can be changed without losing control of the whole.
The next generation of enterprise software may not be defined by how fluently it speaks. It may be defined by how faithfully it expresses what the business intends to do.


