One of the biggest challenges when building AI systems for finance is consistency.
If a user asks the same financial question twice, they expect the same answer.
But many AI systems are inherently non-deterministic. The same inputs can produce slightly different outputs each time. That may be acceptable for general chat. It’s far less acceptable when someone is asking about retirement, investments, or financial planning.
The deeper issue isn’t just randomness.
Large language models are excellent reasoning engines, but they do not naturally maintain stable numerical state. When a model performs calculations, it reconstructs numbers from text and approximates intermediate steps. Over long reasoning chains, small arithmetic inconsistencies can appear.
In most domains, that may not matter. In finance, it absolutely does.
A small change in a portfolio total or withdrawal rate can lead to completely different conclusions about retirement feasibility or financial risk.
Because of this, Ask Linc was designed with a different architecture.
The financial calculations themselves are deterministic.
The AI’s role is to interpret and explain the results.
A system is deterministic when:
The same inputs always produce the same outputs.
This property is important for financial systems for several reasons.
If a user receives a financial answer, the system must be able to reproduce the exact calculation later for debugging or auditing.
Users should receive stable results when asking the same question.
Financial analysis should have a clear trail showing how the result was generated.
To achieve this, Ask Linc separates the system into two layers:
Deterministic financial engines
LLM reasoning and explanation
The financial engine performs the calculations.
The AI explains what those calculations mean.
At the core of the system is a canonical financial snapshot.
This snapshot aggregates the user’s financial data and transforms it into a structured model that can be analyzed consistently. It includes information such as:
account balances
asset allocations
historical transactions
derived income and expenses
portfolio analytics
retirement simulation results
Every value in this snapshot is computed using explicit formulas.
For example:
netWorth = totalCash + totalInvestments + homeValue − totalDebt
Or:
withdrawalRate = annualWithdrawal / portfolioValue
These values are calculated once and treated as authoritative.
When the AI receives the context, it sees something like:
Portfolio value: $1,240,000
Annual withdrawal: $60,000
Historical survival rate: 84%
Worst depletion year: 22
The model does not recalculate these numbers.
Its job is to interpret them and explain the implications.
This separation between deterministic calculations and AI reasoning is central to how Ask Linc works.
Retirement planning is one of the areas where deterministic modeling is especially important.
Many financial tools estimate retirement outcomes using Monte Carlo simulations. While useful, Monte Carlo introduces randomness. Each run can produce slightly different results depending on the simulated market paths.
Ask Linc takes a different approach.
Instead of generating synthetic scenarios, the system evaluates retirement outcomes using rolling historical market sequences.
The question it asks is simple:
If retirement had started at different points in history, would the portfolio have survived the withdrawal period?
To answer this, the engine analyzes retirement outcomes across real historical environments such as:
1970–1980
1971–1981
1972–1982
and so on.
Each sequence represents a real historical market period.
Because the same historical data is used every time, the analysis is deterministic.
This historical approach forms the basis of Ask Linc’s retirement stress testing engine.
Rather than modeling hypothetical futures, the system evaluates how a portfolio would have performed across historical market environments.
Each stress test sequence contains real historical data for:
U.S. equities
international equities
bonds
cash
inflation
For each sequence, the system runs a month-by-month withdrawal simulation.
During the simulation it:
applies asset returns
adjusts withdrawals for inflation
rebalances the portfolio annually
tracks portfolio drawdowns
detects potential depletion
Because the simulation uses fixed historical data and deterministic arithmetic, the results are reproducible.
Running the same portfolio and withdrawal assumptions always produces the same outputs.
The results are then aggregated across all historical sequences to compute metrics such as:
survival rate across historical periods
depletion percentiles
worst historical sequences by drawdown
longest recovery periods
These outputs become part of the structured financial context provided to the AI model.
The model does not run the stress test itself. It interprets the results and explains what they mean for the user’s financial plan.
Retirement simulations must also account for inflation.
Instead of generating random inflation scenarios, Ask Linc derives inflation directly from historical CPI data.
Monthly inflation is calculated from the CPIAUCSL series from FRED, producing a deterministic inflation path aligned with each historical market sequence.
When historical CPI data is available, inflation adjustments are fully deterministic.
If the data source is temporarily unavailable, the system falls back to a fixed long-term inflation assumption of roughly 3.2% annually.
This ensures the analysis remains reproducible.
Before generating an answer, Ask Linc constructs a structured context describing the user’s financial situation.
Most of this context is deterministic because it comes from stored financial data and deterministic calculations.
Examples include:
Accounts
Balances and asset allocations retrieved from the latest financial snapshot.
Transactions
Historical transaction data used to derive income and spending patterns.
Income analysis
Average income calculated from transaction history.
Expense analysis
Spending levels derived from categorized transactions.
Portfolio analytics
Allocation breakdowns and investment performance metrics.
Retirement stress test results
Survival probabilities, drawdown scenarios, and depletion timelines produced by the retirement engine.
When the underlying data does not change, the resulting context snapshot is identical.
This means the AI receives the same financial state each time a question is asked.
Even with deterministic financial calculations, some parts of the system remain inherently non-deterministic.
These components involve AI models or external data sources.
Ask Linc may enrich a user’s financial profile using Plaid insights combined with AI analysis. Because this step uses an LLM, results can vary slightly between runs.
Economic data may be summarized by an AI model. Once the summary is cached, it becomes deterministic, but the initial generation step is not.
New transactions may be categorized using AI when first ingested. After the categorization is stored, the result becomes deterministic.
Some explanations rely on external search APIs. Because search indexes evolve over time, identical queries may return different results.
When Ask Linc answers a financial question, the system follows roughly this pipeline:
Assemble deterministic financial context
Retrieve relevant financial knowledge (RAG)
Run deterministic financial calculations
Send structured context to the reasoning model
Optionally validate the response with a second model
The key principle is simple:
The AI explains financial analysis.
It does not invent the underlying numbers.
Large language models are powerful reasoning systems.
But they are not financial engines.
By separating deterministic calculations from AI reasoning, Ask Linc combines the strengths of both systems:
deterministic financial modeling
structured financial data
historical market stress testing
AI explanation and interpretation
This architecture dramatically reduces the risk of hallucinated numbers and makes financial answers more consistent, auditable, and trustworthy.
As AI systems expand into domains like finance, medicine, and law, architecture matters.
The most reliable systems will not rely on a single model generating answers from scratch.
Instead, they will combine:
structured data systems
deterministic calculations
retrieval pipelines
AI reasoning layers
In other words:
The future of AI applications isn’t just better models.
It’s better systems built around those models.
No posts
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.