When Agents Converge: LLMs, Policy, and Mathematical Solvers as Peers

There is a pattern emerging in enterprise AI that is easy to miss because it does not look like what we have been promised.

The promise was a single model – increasingly capable, increasingly autonomous – that would handle the full complexity of organizational decision-making. Draft the plan, check the constraints, find the optimal answer, explain the tradeoffs, and send the email. One system. One interface. One point of control.

What practitioners keep rediscovering is that this is not how good decisions actually get made. Not in organizations, and not in software.

Good decisions involve different kinds of reasoning working together. Intuition and framing on one side. Formal verification on the other. Negotiation in the middle. The insight of Converge – and the stack we have been building on top of it – is that agent architectures should be designed around this pluralism, not in spite of it.

The Convergence Model

Converge is the implemented low-level contract: kernel, shared context, facts, authority boundaries, promotions, and bounded convergence. It does not own the whole runtime, message bus, or deployment environment. Runtime-Runway supplies capabilities such as messaging and storage around the components.

The contracts center on a single primitive: the Suggestor. A Suggestor reads facts from a shared context and proposes new facts, each tagged with a confidence score. It declares what it reads, what it accepts, what it costs, and what it produces. Nothing else.

Formation helps choose the Formation: the reasoning arrangement for an attempt. Converge runs the governed loop over proposals and shared context. A fixed point is stability under that loop's rules, not necessarily an acceptable answer. An attempt may also stop before reaching one.

Multiple attempts can run in parallel with different formations, budgets, or resources. Zero or more may meet the same Business Truth. Competition and Huddle provide different reasoning structures; neither guarantees success.

Evidence must retain its kind. A heuristic result, a feasible solution, an optimum proved within a formal model, and an independently verified proof are different claims. A numerical confidence label does not make them interchangeable, and none grants authority to commit. Promotion and authorization remain governed boundaries.

A fast approximate answer and a slower solver can run in parallel. Compare their results against the declared evidence requirement. A feasible plan can be enough when the specification permits it; an optimality requirement cannot be satisfied by relabeling an unproved result.

Formation: The Intelligence Layer

Converge handles the convergence loop. Formation handles the intelligence above it.

Where Converge is concerned with how a Formation reaches a fixed point, Formation is concerned with what the Formation is trying to accomplish – and whether that goal is well-formed.

Formation works with structured intent describing outcomes, not steps. It helps plan and review formations for the problem. Each attempt returns its actual result, evidence, and stopping reason; a failed or budget-limited attempt is not reported as a successful fixed point.

Around this pipeline Formation adds two things that operational intelligence actually requires.

The first is adversarial review. Before a plan is committed, a set of skeptic agents – assumption breakers, constraint checkers, edge-case generators – challenge it. This is not validation in the traditional sense. It is structured disagreement, automated. A planning session that passes adversarial review has survived challenges that a human reviewer would raise. One that fails surfaces the specific assumption that broke.

The second is collaborative planning – what Formation calls a Huddle. Multiple models, potentially with different capabilities, different providers, different temperature settings, reason together on the same problem. They do not take turns. They debate. The debate loop runs until participant positions converge, or until the time budget closes. The transcript is evidence, not just output.

Together, Converge and Formation describe an architecture where language models do what they are actually good at: framing, communicating, generating candidates, explaining results. The hard structural reasoning – what is feasible, what is optimal, what is authorized – is handled by systems designed for exactly that.

Ferrox: The Solver Layer

Language models are not optimizers. This is not a criticism; it is a description.

Given a scheduling problem with forty technicians, two hundred work orders, individual certifications, time windows, and labour agreements, a language model will produce a plausible-sounding schedule. It cannot prove that schedule is optimal. It cannot tell you how far from optimal it is. It cannot guarantee that every constraint has been respected. On sufficiently complex instances, it cannot reliably find a feasible answer at all.

Ferrox is the answer to that gap. It exposes Google OR-Tools CP-SAT and HiGHS MIP – two of the strongest open-source mathematical solvers available – as first-class Converge Suggestors. They register in a Formation alongside LLM agents. They read the same context. They write confidence-scored plans to the same strategy space. The Formation handles the rest.

For every problem class, two implementations compete:

A greedy heuristic runs in microseconds. It seeds a baseline answer immediately and gives the downstream pipeline something to work with while the exact solver is running. Its confidence is capped – it cannot prove optimality.

A CP-SAT or MIP solver runs in parallel. It may establish feasibility, prove optimality within its model, prove infeasibility, or stop without settling the question. Preserve the actual status, bounds, assumptions, and budget. Timeout is not an infeasibility proof.

The greedy answer and solver results coexist in the record. Downstream consumers must inspect their evidence and status, not rank unlike claims solely by a confidence number. Selecting a plan remains separate from authorizing an undertaking.

Three Problems That Matter

The benchmark numbers from Ferrox's three problem domains are worth dwelling on, not because they demonstrate solver performance in the abstract, but because each one is a real decision class with real organizational consequences.

Field Service Scheduling

A utilities company has twelve specialist technicians and sixty work orders arriving each morning. Each order requires a specific certification. Each has a committed customer time window. The horizon is six hours.

Ferrox's greedy EDF scheduler – sorting by deadline, assigning the earliest available capable agent – runs in 0.03 milliseconds and schedules 56 of 60 tasks. Respectable. On most mornings, no one would notice the four that got dropped.

CP-SAT, running in parallel for 260 milliseconds, schedules all 60. It proves this is the maximum achievable given the constraints. The difference is not four work orders in the abstract. It is four customer appointments that either happen today or get rescheduled, four SLA credits that either stay in the bank or get paid out, four technicians whose morning either has slack or runs long.

At scale – forty technicians, eight hundred work orders per week – the compounding is material. The gap between heuristic and optimal scheduling is not a technical curiosity. It is headcount.

What makes this a Formation problem rather than a pure solver problem is everything that surrounds the optimization. An LLM agent reads the raw work orders from emails and PDFs, extracts the structured data, and seeds the scheduling request into context. A Cedar policy engine checks labour agreements – no technician works more than ten hours, union jurisdiction applies by zone – before the scheduler sees the request. After the CP-SAT plan is confirmed, a second LLM agent drafts the technician briefings, the customer ETA notifications, and the manager summary. No single component does the whole job. Their outputs still require evidence checks and the authority needed for any resulting commitment.

Capital Allocation

A fund manager needs to deploy fifty million euros across a shortlist of projects. Returns are estimated. Risks are scored. Regulations prohibit concentrating more than forty percent of capital in any single sector. ESG policy requires at least three sustainable investments in the portfolio.

The combinatorial space here is not exotic. With thirty candidate projects, there are roughly a billion possible portfolios. A language model navigating this intuitively will produce something that looks right – until it checks the sector cap and finds it is three points over, or counts the ESG flags and realizes it has only two.

HiGHS can model this as a binary knapsack: maximize expected return under capital constraints, sector limits, and ESG minimums. Retain the actual solver status and optimality gap. A proved optimum is relative to this formal model and its estimated inputs; a time-limited feasible portfolio is a different evidence claim.

The Cedar policy layer can exclude candidates from the solver's authorized input view. The original proposals, their evidence, and the reasons for rejection remain in append-only history. HiGHS optimizes over the permitted candidates; a filtered view does not erase what was proposed or what influenced an earlier decision.

When a portfolio meets the declared evidence requirement, an LLM can draft the investment committee memo. It should explain sector distribution, excluded alternatives, uncertainty, and actual solver status. Selection and authority to commit capital remain separate checks.

Factory Floor Planning

A precision manufacturer's job shop runs ten machines across three shifts. Each evening, a new batch arrives: fifteen to thirty jobs, each requiring a fixed sequence of machining operations. No two jobs can occupy the same machine simultaneously. Finishing the batch sooner frees capacity for the next shift. The target is to minimize makespan.

This is the canonical NP-hard scheduling problem. Greedy SPT dispatching – always running the shortest available operation first – produces a valid schedule in under a millisecond. On a fifteen-job, ten-machine instance, that schedule has a makespan of 2,038 time units.

CP-SAT, given a thirty-second budget, produces a schedule with makespan 1,044 – 48.8 percent shorter. On a three-shift operation, that is not 48.8 percent more jobs per shift. The relationship is nonlinear. A schedule that finishes the batch forty-nine percent sooner does not just start the next batch earlier. It changes what becomes possible about shift overlap, maintenance windows, and the decision about whether to add a weekend run.

The formation around this optimization does what formations do. An LLM reads the ERP export and production notes, identifies rush jobs and quality holds, and seeds a structured JobShopRequest into context. Cedar enforces maintenance windows and operator certifications. The greedy and CP-SAT Suggestors run concurrently – the floor supervisor's screen shows the baseline immediately, then updates with the solver result and its actual feasibility or optimality status. An LLM writes the handover notes and flags any rush jobs that risk missing their committed window.

The math produces the schedule. The Formation makes it usable.

What Fixed Points Mean

The phrase "fixed point" in mathematics refers to a value that maps to itself under a given function. In the Converge model, a Formation reaches a fixed point when no registered Suggestor can improve on the current state of the context. The engine has converged. The answer is stable.

This property matters for a reason that is easy to overlook. Most agent architectures are pipelines: step one feeds step two, step two feeds step three. A pipeline's correctness depends on each step being correct, in order. An error in step two corrupts every step that follows. And when you want to add a new capability – a new solver, a new policy check, a new verification layer – you have to decide where in the sequence it goes, and whether it breaks the steps around it.

A Formation avoids hard-coding a handoff chain between every contributor. Contributors read authorized context and propose changes through the kernel's contracts. Independence from execution order is conditional on the relevant confluence assumptions; it cannot be inferred for arbitrary fresh LLM calls or budget-limited schedules.

This lets solver Suggestors and language-model contributors use shared interfaces without calling each other directly. Their outputs remain distinct claims with provenance and evidence. A promoted fact belongs to the governed record; promotion alone does not prove it true of the world.

A Formation can be extended with solvers, explanation layers, policy checks, or adversarial reviewers. Each change needs its own evaluation: an extra contributor may alter cost, outcomes, and convergence behavior. Preserve earlier attempts rather than rewriting them to match the improved formation.

The Composition That Actually Works

Converge, Formation, and Ferrox compose specialized agents in a Formation. Their proposals are evaluated within a governed convergence loop; agreement among the agents does not by itself authorize a commitment.

Language models handle what they are genuinely good at: understanding unstructured input, generating narrative, explaining decisions in terms a human can act on. Cedar policy handles authorization: the hard rules that cannot be softened by context or confidence. Mathematical solvers handle optimization: the problems where the combinatorial space is too large for intuition and where the cost of a suboptimal answer is measurable.

None of these technologies substitutes for the others. Assess the result against the Business Truth, select among acceptable candidates, and obtain the authority needed for commitment. If nothing meets the requirements, record that outcome and consider a revised attempt.

That is the fixed point worth reaching.