DEV Community: Dr. Gustavo Henrique Valente

Prof. Dr. Gustavo Henrique Valente: Building a Regime-Detection Layer for Brazilian Market Data

Dr. Gustavo Henrique Valente — Tue, 07 Jul 2026 09:14:07 +0000

Most financial dashboards start with prices.

For a developer building analytical tools, that is understandable. Prices are available, easy to chart and simple to compare.

But for portfolio-risk analysis, price is usually the final output of several deeper states.

In Brazilian markets, those states include interest rates, inflation, currency, equity breadth and cross-asset correlation.

A regime-detection layer should try to classify those states before making any interpretation of asset performance.

The Goal

The purpose of the system is not to predict the next Ibovespa close or the next USD/BRL tick.

The purpose is to answer a more useful question:

What environment is the portfolio currently operating in?

A practical system might classify Brazil’s market state into categories such as:

Restrictive rates.

Inflation persistence.

Currency support.

Currency pressure.

Narrow equity breadth.

Broad equity participation.

Correlation stress.

Mixed or uncertain regime.

The final label should always include a confidence score.

Data Blocks

The first block is rates.

Useful inputs may include the Selic rate, DI futures, nominal yields, inflation expectations and estimated real rates.

The system should detect whether rates are moving in parallel, steepening, flattening or diverging between the front end and long end.

The second block is inflation.

The system should not store only the headline number. It should separate food, services, housing, regulated prices and imported categories when available.

Different categories have different persistence.

The third block is currency.

USD/BRL should be decomposed into possible drivers: interest-rate differential, global dollar strength, commodity conditions, local risk premium and foreign capital flows.

The fourth block is equity breadth.

This can include sector participation, advancing versus declining names, turnover concentration and the share of index movement explained by a small group of companies.

The fifth block is correlation.

Rolling correlations across equities, bonds, currency, commodities and digital assets can indicate whether diversification is becoming more fragile.

Simple System Design

A clean architecture might contain five stages.

Data ingestion.

Feature engineering.

Signal classification.

Confidence scoring.

Human-readable explanation.

The explanation layer is essential.

A model that says “currency pressure is rising” should also explain whether that signal comes from the global dollar, local rates, commodity movement or market liquidity.

Without an explanation layer, the system becomes a black box.

Black boxes are difficult to govern in financial environments.

Example Feature Logic

For the rates block:

If the Selic is high, real rates are positive and the long end of the curve rises faster than the front end, the system may classify the rate regime as restrictive with long-end stress.

For the inflation block:

If headline inflation falls but service inflation and expectations remain firm, the system should avoid classifying inflation risk as fully resolved.

For the currency block:

If the real strengthens while the global dollar weakens, the model should not automatically attribute the move to domestic improvement.

For the breadth block:

If the equity index rises while participation narrows, the market state should be marked as less robust.

For the correlation block:

If rolling correlations rise across assets during volatility, the system should flag diversification stress.

Why This Matters

Developers often measure model quality by prediction accuracy.

In portfolio systems, interpretability and stability can be just as important.

A regime classifier that correctly identifies rising uncertainty may help risk managers even if it never predicts an exact price.

The model should tell users when confidence is high, when signals are mixed and when human review is required.

That is especially important in Brazil, where monetary policy, inflation, fiscal expectations, currency movement and global liquidity often interact quickly.

Final Principle

A good financial AI system should not try to sound certain.

It should try to be useful.

For Brazilian market data, usefulness begins with recognizing that prices are not the whole story.

They are the result of changing regimes.

Build the state layer first.

Interpret the price later.

https://www.profdrgustavohenriquevalente.com/

Prof. Dr. Gustavo Henrique Valente: Designing a Regime-Detection Pipeline for Brazilian Portfolio Risk

Dr. Gustavo Henrique Valente — Thu, 02 Jul 2026 07:32:48 +0000

Financial dashboards often begin with prices. A more useful risk system begins with states.

For a Brazilian portfolio, the objective should not be to build a model that produces one confident prediction for the Ibovespa or USD/BRL. The objective should be to identify the environment in which those assets are operating.

A practical regime-detection pipeline can be organized around five data blocks: interest rates, inflation, currency, commodities and market liquidity.

Build the Interest-Rate Block

The current Selic target is 14.25%, but a system should not store only the policy rate.

It should also collect the DI futures curve, inflation expectations, nominal government-bond yields and estimated real rates. The curve can then be represented through level, slope and curvature features.

A simple feature set might include:

rate_features = {
“selic”: current_selic,
“front_end_slope”: di_1y - selic,
“long_end_slope”: di_5y - di_1y,
“expected_real_rate”: di_2y - expected_inflation,
“curve_volatility”: rolling_std(di_curve_changes)
}

The model should distinguish between a parallel fall in yields and a steepening event in which short-term yields decline while long-term yields rise.

Those two conditions may have very different implications for credit, valuation and portfolio duration.

Preserve the Structure of Inflation

June’s IPCA-15 rose 0.41%, with the twelve-month measure at 4.80%.

A weak data pipeline would store only those two figures.

A stronger system would preserve category-level information such as food, housing, energy, services, regulated prices and transportation. It would also record diffusion, revisions and the distance between actual inflation and market expectations.

The system should not assume that every inflation increase has the same persistence.

A regulated electricity adjustment, a food-supply shock and broad service inflation belong to different causal groups. They should not receive identical model weights.

Treat Currency as a Multi-Driver Variable

The official dollar reference rate ended June close to R$5.18.

USD/BRL should not be modeled as a direct function of the Selic rate alone. The currency also responds to the global dollar cycle, commodity prices, fiscal expectations, international risk appetite and hedging demand.

A useful pipeline can create separate driver scores:

currency_state = weighted_score(
carry_signal,
global_dollar_signal,
commodity_signal,
fiscal_risk_signal,
foreign_flow_signal
)

The purpose of this score is not to predict an exact exchange rate.

It is to identify which force currently dominates the currency regime and whether that dominance is stable.

Separate Commodity Exposure from the Domestic Economy

Brazilian assets often react to oil, iron ore and agricultural prices, but the relationship is not uniform.

Commodity exporters may benefit from stronger external prices while domestic consumers face different effects through fuel, food and inflation expectations.

The data layer should therefore separate commodity prices, terms of trade, export volumes and company-level exposure.

A broad “commodity up” feature is too crude for portfolio-risk analysis.

Measure Liquidity and Participation

The Ibovespa closed July 1 near 171,689 points. The index level alone cannot show whether market participation is healthy.

A liquidity block should include volume, breadth, bid-ask spreads, foreign flow, concentration and the relationship between cash and futures trading.

A market advance supported by many sectors is different from an advance produced by a few large companies.

Likewise, a small decline with disappearing liquidity may represent more risk than a larger but orderly adjustment.

From Features to Regimes

Once the five blocks are standardized, the system can use clustering, hidden Markov models or supervised classification to identify regimes.

Possible labels might include:

DOMESTIC_EASING
LONG_END_STRESS
CURRENCY_PRESSURE
COMMODITY_SUPPORT
LIQUIDITY_CONTRACTION
MIXED_OR_UNCERTAIN

The final label should always include a confidence score.

If the rate model signals easing while the currency and inflation models signal stress, the system should not force a simple answer. It should classify the environment as mixed and increase uncertainty.

Monitoring Model Failure

Brazilian financial data contains structural breaks. Fiscal frameworks change. Policy communication changes. Commodity cycles change. Global funding conditions change.

Every production system should therefore monitor data drift, feature drift and regime instability.

It should also maintain a human-readable explanation of why a classification changed.

An unexplained output may be statistically sophisticated but operationally weak.

Final Principle

The best financial AI system is not the one that predicts every market move.

It is the one that helps investors recognize when their assumptions are becoming less reliable.

For Brazilian portfolios, regime detection provides a disciplined way to connect rates, inflation, currency, commodities and liquidity without pretending that uncertainty has disappeared.

Prof. Dr. Gustavo Henrique Valente: Designing AI Systems for Probability Thinking, Not False Certainty

Dr. Gustavo Henrique Valente — Fri, 26 Jun 2026 07:08:21 +0000

Many AI systems in finance are designed around one tempting goal: prediction.

The user asks for a market signal.
The model returns an output.
The dashboard displays a score.
The interface may make the result look clean, precise, and actionable.

But financial markets are not deterministic systems.

They are noisy, adaptive, and sensitive to changes in liquidity, policy, positioning, valuation, investor behavior, and unexpected events. A model can estimate probabilities, but it cannot remove uncertainty.

For developers building financial research tools, this distinction is important.

The goal should not be to design systems that pretend to know the future.

The goal should be to design systems that help users understand uncertainty more clearly.

Prediction Interfaces Can Create Overconfidence

A common design mistake is presenting model output as if it were a final answer.

For example:

Risk score: Low
Expected direction: Positive
Confidence: High

This may be visually efficient, but it can create a dangerous user experience. The user may interpret the output as certainty, especially if the interface does not explain assumptions, data limits, model drift, or scenario risk.

In finance, overconfidence is not only a behavioral problem.

It can become a system design problem.

If the interface hides uncertainty, the product may unintentionally encourage users to take more risk than they understand.

Probability Thinking Requires Better System Design

A probability-aware financial AI system should help users ask better questions.

Instead of only displaying a signal, the system should explain the uncertainty around the signal.

Useful elements may include:

Scenario ranges
Confidence intervals
Data freshness indicators
Model drift warnings
Assumption summaries
Stress-case comparisons
Correlation change alerts
Liquidity risk flags
Human review checkpoints

These features do not make a system weaker.

They make it more honest.

The purpose of AI-assisted finance tools should not be to remove doubt artificially. It should be to organize uncertainty in a way that supports better review.

Model Output Should Be Interpretable

If a model classifies a portfolio environment as “stable,” the user should understand what that classification depends on.

Is the classification based on volatility?
Liquidity?
Correlation?
Macroeconomic inputs?
Historical patterns?
Market regime clustering?
Alternative data?

Without context, users may trust the label too much.

A better design explains what the model considered, what it ignored, and what conditions could make the output unreliable.

In technical terms, this means that model interpretability is not only a research preference.

It is a risk-control feature.

Financial Models Must Expect Regime Change

Financial data is not stationary in the way many systems would prefer.

Relationships change.

Correlations can rise under stress.
Liquidity can disappear quickly.
Volatility can shift across regimes.
Investor behavior can change after policy or macro shocks.
A model that worked in one period may weaken in another.

This is why AI-assisted financial systems should be built with monitoring layers.

Developers should consider:

How is model drift detected?
How are changing correlations flagged?
How often is the model reviewed?
What happens when data quality declines?
Does the system alert users when assumptions are weakening?

These questions are not only about performance.

They are about responsibility.

AI Should Support Human Judgment

AI can process more data than a human researcher can review manually.

It can detect patterns, summarize information, and monitor risk variables efficiently.

But AI should support human judgment, not replace it.

A responsible financial AI system should make it easier for the human user to understand probability, uncertainty, and risk exposure. It should not create a black box that encourages blind trust.

The developer’s responsibility is not only to build a model that works in a test environment.

It is to build a system that communicates uncertainty clearly in the real world.

A Simple Probability-Aware Design Principle

A useful principle for financial AI design is:

Never show a prediction without showing uncertainty.

This can be implemented in many ways.

If the system shows an expected return, show a risk range.

If it shows a signal, show confidence and limitations.

If it shows a portfolio score, show exposure drivers.

If it shows a model recommendation, show assumptions and stress cases.

If it shows historical performance, show regime sensitivity.

This approach helps prevent users from confusing model precision with market certainty.

Final Thought

AI can improve financial research.

But the best AI systems should not make users believe the future is knowable.

They should help users understand what is probable, what is uncertain, what is fragile, and what needs review.

For developers, this means designing with humility.

Good financial AI is not only about prediction accuracy.

It is about communication, interpretability, monitoring, and risk awareness.

The strongest systems do not hide uncertainty.

They make uncertainty visible.

Building Risk Budget Checks Into Portfolio Analytics Systems

Dr. Gustavo Henrique Valente — Mon, 22 Jun 2026 08:37:37 +0000

In financial software, it is easy to focus on performance metrics.

Returns are simple to display. Charts are easy to generate. Rankings are easy to compare.

Risk is more difficult.

Risk requires context, assumptions, and interpretation. It is not only a number. It is a system of exposures that can change when market conditions change.

For developers building portfolio analytics tools, this creates an important design challenge:

A portfolio dashboard should not only show what performed well. It should help users understand what risks are being carried.

This is where the concept of a risk budget becomes useful.

What Is a Risk Budget in Software Terms?

A risk budget is a framework that defines how much uncertainty a portfolio is allowed to carry and where that uncertainty comes from.

In software terms, this can be translated into checks, limits, alerts, and review layers.

Examples include:

Maximum exposure by asset class
Maximum exposure by region
Maximum exposure to a single factor
Volatility threshold
Drawdown threshold
Liquidity warning
Concentration warning
Correlation change alert
Model drift alert

The goal is not to eliminate risk.

The goal is to make risk visible.

Why Return-First Dashboards Can Be Misleading

Many dashboards prioritize performance first.

This may create a clean user experience, but it can also create a dangerous mental model.

If the interface shows return without showing risk, users may interpret performance as skill even when it is driven by concentration, leverage, liquidity exposure, or a temporary market regime.

A more responsible analytics system should place return beside risk.

For example, instead of only showing:

Portfolio return: 12%

A better system may also show:

Largest exposure source
Estimated volatility range
Drawdown history
Liquidity sensitivity
Correlation concentration
Stress scenario behavior

This does not make the dashboard more complicated for the sake of complexity.

It makes the output more honest.

Risk Checks Should Be Designed Before Optimization

A common mistake in portfolio tools is to optimize first and constrain later.

A better process is to define risk constraints before optimization.

The system should ask:

What is the maximum acceptable exposure?
Which risk factors should be limited?
How much concentration is allowed?
Should illiquid assets be capped?
Should correlations be monitored dynamically?
Should the model warn users when historical assumptions weaken?

These questions help prevent a system from producing a mathematically attractive but practically fragile allocation.

Optimization without constraints can create false precision.

Risk budgeting adds discipline.

AI Can Help, But It Should Not Hide Assumptions

AI can support portfolio analytics by detecting patterns, monitoring correlations, flagging changing market states, and summarizing risk exposures.

But developers should avoid presenting AI output as unquestionable truth.

A responsible system should expose uncertainty.

Useful design patterns include:

Confidence ranges
Model assumption notes
Data freshness indicators
Drift warnings
Scenario comparisons
Human review checkpoints
Clear explanations of limitations

The goal is not to make AI sound certain.

The goal is to help users understand uncertainty more clearly.

A Simple Risk Budget Logic Layer

A basic analytics system may include a logic layer like this:

If asset class exposure exceeds threshold, flag concentration risk.

If rolling volatility exceeds defined range, flag volatility pressure.

If correlations across major holdings rise sharply, flag diversification weakness.

If liquidity score falls below threshold, flag liquidity risk.

If model performance declines after deployment, flag model drift.

If multiple risk flags appear together, trigger a portfolio review warning.

This type of system does not make investment decisions.

It supports better review.

That distinction matters.

Good Financial Tools Should Reduce Overconfidence

The purpose of portfolio analytics should not be to make users feel certain.

It should help them become more aware of risk.

A well-designed financial tool should make hidden exposures visible, identify when assumptions are weakening, and encourage disciplined review before market stress appears.

This is especially important in AI-assisted systems.

The more advanced a model appears, the more important it becomes to communicate its limits clearly.

Good software should not turn probability into false certainty.

Final Thought

A return target without a risk budget is only an ambition.

For developers, the practical lesson is simple:

Do not build portfolio analytics tools that only celebrate performance.

Build tools that show exposure, uncertainty, concentration, liquidity, and model limitations.

AI can support this process.

But judgment, responsibility, and risk discipline must remain part of the system design.

AI Does Not Replace Judgment: A Developer’s View of Financial Model Risk

Dr. Gustavo Henrique Valente — Thu, 18 Jun 2026 08:03:29 +0000

Artificial intelligence is becoming increasingly visible in financial research, portfolio analytics, risk monitoring, and market data interpretation.

For developers and data scientists, this creates an interesting challenge.

The problem is not whether AI can process financial data. It can.

The deeper problem is whether the people building and using these systems understand what the model does not know.

In financial markets, uncertainty is not a bug in the system. It is part of the environment. A model can detect patterns, classify regimes, estimate risk, and identify relationships in historical data. But it cannot guarantee that the future will behave like the past.

This is why AI should support investment judgment, not replace it.

Financial Data Is Not Static

Many software systems are built around relatively stable rules.

Financial markets are different.

The data-generating process can change. Interest rates shift. Liquidity conditions tighten. Market participants change behavior. Policy expectations move. Correlations that looked stable in one period may weaken or reverse in another.

A model trained during one market environment may not perform the same way in the next.

For developers, this means one important thing:

Model accuracy should never be viewed as permanent.

A system used for financial research needs continuous monitoring, validation, and review. It is not enough to deploy a model once and assume that historical performance proves future reliability.

Prediction Is Not the Same as Risk Management

A common mistake in AI-driven finance is treating prediction as the final goal.

Prediction may be useful, but it is incomplete.

A responsible system should also ask:

What happens if the prediction is wrong?
How sensitive is the output to the input data?
Is the model too dependent on one market regime?
Are there hidden concentration risks?
How does the system behave under stress?

These questions are not only financial questions. They are engineering questions.

Robust systems are not designed only for ideal conditions. They are designed to fail safely, surface uncertainty, and prevent users from confusing model output with certainty.

In this sense, financial AI should be built with humility.

Model Output Needs Context

A probability score, risk classification, or market signal can look precise.

But precision is not the same as truth.

For example, a model may classify an environment as “low risk” because recent volatility has declined. But if liquidity is thin, leverage is high, or macro conditions are unstable, the surface-level signal may be incomplete.

This is where human judgment remains necessary.

The model can summarize patterns.
The researcher must interpret meaning.
The developer must design the system so users understand limitations.

A useful AI system should not simply return an answer. It should help users understand the confidence, assumptions, and risks behind that answer.

A Practical Checklist for Developers

When building or reviewing AI-assisted financial research tools, I find the following checklist useful:

Data quality: Is the input data clean, timely, and relevant?

Data bias: Does the training set overrepresent one market period?

Model drift: Is performance being monitored after deployment?

Explainability: Can users understand why the model produced an output?

Stress testing: How does the system behave during unusual market conditions?

Risk communication: Does the interface communicate uncertainty clearly?

Human review: Is there a process for expert review before decisions are made?

This checklist does not eliminate risk.

But it helps prevent a dangerous assumption: that a model is reliable simply because it is mathematically sophisticated.

Good Financial AI Should Reduce Overconfidence

One of the most valuable roles of AI in finance is not to make investors more confident.

It is to make them more aware of uncertainty.

A well-designed system should help users see where assumptions are fragile, where correlations are changing, where exposures are concentrated, and where historical data may not be enough.

In other words, AI should improve the quality of questions.

It should not create the illusion that questions are no longer needed.

For developers, this is an important design principle. The best financial AI tools are not black boxes that produce final answers. They are decision-support systems that improve visibility, structure, and risk awareness.

The Human Layer Still Matters

Financial decisions are not made in a vacuum.

They involve constraints, objectives, time horizons, liquidity needs, regulatory considerations, and behavioral pressure. A model can support analysis, but it does not fully understand the human context in which decisions are made.

That is why judgment remains essential.

AI can process information faster than humans.
AI can detect patterns that humans may miss.
AI can assist with portfolio research and risk monitoring.

But AI cannot take responsibility for assumptions, consequences, or ethical use.

That responsibility remains human.

Final Thought

AI does not replace judgment.

It improves research when it is used carefully, reviewed honestly, and placed inside a disciplined risk-management framework.

For developers working in financial technology, the goal should not be to build systems that pretend to know the future.

The goal should be to build systems that help people understand uncertainty more clearly.

That is where AI becomes useful.

Not as an oracle.

As a research assistant.

— Prof. Dr. Gustavo Henrique Valente