The problem is simple: an agent can look busy while wasting compute — repeating reads, retrying commands, re-checking unchanged state, or choosing expensive actions that add little progress.

MARGINAL sits in the loop and asks whether the next action is actually worth executing.

It starts in observation mode, collects evidence, and only earns narrow enforcement when the pattern is strong enough. If the evidence is weak or ambiguous, it fails open.

I also built an interactive demo that runs the same coding task side-by-side, with and without MARGINAL, so you can watch calls, tokens, declared cost and decisions diverge step by step in the browser.

Repo: https://github.com/SignalLayerLabs/Marginal
Live demo: https://signallayerlabs.github.io/Marginal/demo/

If you’re building agents, orchestration, evals, observability or guardrails, I’d especially like feedback on the decision model — or forks that take the same idea into different agent workflows.

I’m building MARGINAL, an open-source runtime governor for AI coding agents.

The problem I’m targeting is simple: agents can keep spending tokens, calling tools, re-checking things, or choosing expensive actions without enough evidence that the extra work is actually useful.

MARGINAL sits in the loop and asks a different question:

Is this next action worth spending compute on?

I just rebuilt the demo so it’s no longer a marketing page. It’s an actual interactive browser simulation.

You press RUN THE SAME TASK and two agents start from the exact same broken Python workspace at the same time:

WITHOUT MARGINAL
Executes every candidate action.

WITH MARGINAL
Scores the same candidates before execution and either:

FUND + EXECUTE

or

REJECT BEFORE SPEND

You can pause it, advance step-by-step, reset it, or run it at different speeds while watching tokens, calls, estimated cost, declared latency, workspace state, and MARGINAL’s decision reasoning update live.

Both sides must reach the same verifier PASS.

The included deterministic fixture currently ends at:

72,800 → 4,300 declared tokens
9 → 3 actions
PASS → PASS

Those are declared deterministic demo costs, not provider telemetry or a claim of 94% savings in real workloads. The point is to make the governance mechanism inspectable instead of hiding it behind a benchmark number.

MARGINAL is open source, local-first, provider-neutral, and starts from the principle:

Observe first. Prove waste. Earn enforcement.

Repo:
https://github.com/SignalLayerLabs/Marginal

Interactive demo:
https://signallayerlabs.github.io/Marginal/demo/

I’m especially interested in people trying to break the decision logic, finding cases where an action MARGINAL rejects was actually valuable, or contributing adapters for other coding agents.

I’ve been working on MARGINAL, an open-source governance layer for coding agents. If you use Codex, I’d really appreciate people trying it on real work and telling me where it helps, where it gets in the way, or where the design is wrong.

I’m especially interested in: technical criticism, bad cases, and reproducible failures.

• GitHub: https://github.com/SignalLayerLabs/Marginal
• GitHub Site: https://signallayerlabs.github.io/Marginal/
• Live Demo: https://signallayerlabs.github.io/Marginal/demo/#demo

The idea is simple: agents are good at taking actions, but not always good at deciding whether the next action is still worth the compute.

MARGINAL watches the trajectory and looks for things like repeated actions, weak progress, redundant verification, and low-value continuation. It can run in Shadow Mode first, so it observes and records what it would have done without blocking anything.

Current focus is reliability, not just token reduction.

A few core pieces:

• local-first trajectory and evidence tracking
• deterministic reason codes and hashes for decisions
• governance overhead measurement
• replay and benchmark support
• Shadow Mode before enforcement
• Earned Enforcement: MARGINAL has to prove it is reliable on a repo before it gets permission to block or redirect the agent
• automatic fallback to Shadow Mode if confidence degrades

I’m also working on the next layer now: counterfactual evaluation and intervention regret.

The goal is to answer a harder question than “did MARGINAL stop something?”:

Would the agent actually have done better if MARGINAL had stayed out of the way?

That’s the part I think matters if this is going to be useful beyond being another loop detector or token limiter.

I’ve been working on MARGINAL, an open-source governance layer for coding agents. If you use Codex, I’d really appreciate people trying it on real work and telling me where it helps, where it gets in the way, or where the design is wrong.

I’m especially interested in: technical criticism, bad cases, and reproducible failures.

• GitHub: https://github.com/SignalLayerLabs/Marginal
• GitHub Site: https://signallayerlabs.github.io/Marginal/

The idea is simple: agents are good at taking actions, but not always good at deciding whether the next action is still worth the compute.

MARGINAL watches the trajectory and looks for things like repeated actions, weak progress, redundant verification, and low-value continuation. It can run in Shadow Mode first, so it observes and records what it would have done without blocking anything.

Current focus is reliability, not just token reduction.

A few core pieces:

• local-first trajectory and evidence tracking
• deterministic reason codes and hashes for decisions
• governance overhead measurement
• replay and benchmark support
• Shadow Mode before enforcement
• Earned Enforcement: MARGINAL has to prove it is reliable on a repo before it gets permission to block or redirect the agent
• automatic fallback to Shadow Mode if confidence degrades

I’m also working on the next layer now: counterfactual evaluation and intervention regret.

The goal is to answer a harder question than “did MARGINAL stop something?”:

Would the agent actually have done better if MARGINAL had stayed out of the way?

That’s the part I think matters if this is going to be useful beyond being another loop detector or token limiter.

I’ve been working on MARGINAL, an open-source governance layer for coding agents.

The idea is simple: agents are good at taking actions, but not always good at deciding whether the next action is still worth the compute.

MARGINAL watches the trajectory and looks for things like repeated actions, weak progress, redundant verification, and low-value continuation. It can run in Shadow Mode first, so it observes and records what it would have done without blocking anything.

Current focus is reliability, not just token reduction.

A few core pieces:

• local-first trajectory and evidence tracking
• deterministic reason codes and hashes for decisions
• governance overhead measurement
• replay and benchmark support
• Shadow Mode before enforcement
• Earned Enforcement: MARGINAL has to prove it is reliable on a repo before it gets permission to block or redirect the agent
• automatic fallback to Shadow Mode if confidence degrades

I’m also working on the next layer now: counterfactual evaluation and intervention regret.

The goal is to answer a harder question than “did MARGINAL stop something?”:

Would the agent actually have done better if MARGINAL had stayed out of the way?

That’s the part I think matters if this is going to be useful beyond being another loop detector or token limiter.

GitHub: https://github.com/SignalLayerLabs/Marginal

Demo: https://signallayerlabs.github.io/Marginal/demo/#demo

If you use Codex or another coding agent, I’d really appreciate people trying it on real work and telling me where it helps, where it gets in the way, or where the design is wrong.

I’m especially interested in: technical criticism, bad cases, and reproducible failures.

Most AI agents operate with one rule:

>

That leads to unnecessary searches, repeated file reads, redundant reviewers, expensive retries and sub-agents that add little value.

I’m building MARGINAL, an open-source compute governance layer that evaluates each proposed action before it consumes tokens.

It asks:

>

MARGINAL can:

• run in Shadow Mode without blocking anything;
• compare expected value against tokens, cost, latency and risk;
• preserve budget for final verification;
• record decisions and real outcomes in a versioned ledger;
• learn which actions are actually useful over time;
• protect sensitive telemetry through explicit privacy profiles.

The long-term goal is not just “use fewer tokens.”

It is to build agents that continuously learn what deserves to be done.

The core is local-first, provider-neutral and has zero mandatory runtime dependencies. We’re now building the universal layer for Codex, Claude Code, GitHub Copilot, OpenCode and other development agents.

Repo: github.com/SignalLayerLabs/Marginal

I’d genuinely value criticism from people building agent runtimes:

What would MARGINAL need before you would trust it to influence your agent’s next action?

Hi everyone,

Most financial AI systems are built behind closed doors.

You see the final prediction, the polished chart or the confident explanation—but rarely the data flow, the reasoning process, the evaluation rules or the failures that came before it.

BLUM is an attempt to build something different.

BLUM is an open-source financial AI research project developed publicly on Hugging Face and opened to developers, quantitative researchers, data scientists and anyone interested in building more transparent financial intelligence.

The ambition is not to create another black-box system that simply outputs:

BUY, SELL or HOLD.

The goal is to create an open ecosystem capable of collecting evidence, producing structured financial reasoning, testing its own conclusions over time and learning only from outcomes that can actually be verified.

Why open source?

Financial AI should not be shaped by one developer, one company or one model.

Markets are too complex, financial evidence is too fragmented and evaluation is too easy to distort.

A serious system needs different perspectives:

• quantitative researchers challenging the metrics;
• developers improving the architecture;
• traders identifying unrealistic assumptions;
• data engineers strengthening market-data pipelines;
• ML researchers testing models and evaluation methods;
• community members finding errors that the original developers missed.

That is the idea behind BLUM:

Build financial intelligence in public, improve it through open collaboration and make every important assumption open to challenge.

BLUM is not presented as a finished product.

It is a shared research foundation that the community can inspect, test, criticize, fork and improve.

What BLUM is building

BLUM combines a portable financial reasoning model with a broader modular research system.

Its architecture is being developed around several specialized capabilities:

• market scanning across equities, ETFs and Forex;
• technical and historical analysis;
• sentiment and news interpretation;
• bullish and bearish thesis generation;
• contradiction and risk detection;
• structured entry, stop and target plans;
• paper-forward trade validation;
• persistent learning from verified outcomes;
• benchmark-relative evaluation;
• transparent evidence and reasoning trails.

Instead of depending on a single model for every task, BLUM can use specialized agents for different parts of the research process.

A simplified flow looks like this:

Market data and external evidence
                ↓
Specialized research agents
                ↓
Bullish, bearish and risk analysis
                ↓
Central reasoning and synthesis
                ↓
Paper-forward decision
                ↓
Outcome measurement
                ↓
Validated learning and memory

The objective is not merely to generate a convincing financial narrative.

The objective is to preserve enough evidence to evaluate whether that narrative was justified.

Built to be challenged

BLUM is being designed around a principle that is often missing from AI demos:

A system should make it possible to prove that it was wrong.

For every decision, BLUM aims to preserve information such as:

• what evidence was available at that moment;
• which assumptions supported the thesis;
• which risks contradicted it;
• what would invalidate the decision;
• which entry, stop and target levels were proposed;
• how the market behaved afterward;
• whether the result was valid enough to enter the learning process.

This does not guarantee better predictions.

It creates a more transparent foundation for measuring whether the system is improving—or merely becoming better at sounding confident.

Current evaluation

The original MLX release was evaluated on a 53-example BLUM temporal-reasoning test and achieved:

• 96.26% aggregate task-contract score
• 100% structured validity
• 92.86% no-fabrication

These metrics evaluate BLUM-specific requirements such as structured output, temporal grounding and adherence to the task contract.

They do not demonstrate market-beating performance, general intelligence or trading profitability.

The portable release is also being prepared for independent evaluation through the Hugging Face ecosystem. Results will be published when they are externally available rather than predicted in advance.

Open development means open limitations

BLUM is still experimental.

Some components are mature enough to be tested, while others remain active research areas. Its paper-forward evidence is still limited, and no current result should be interpreted as proof of profitable trading performance.

This is intentional.

The project will not hide weak results, unsuccessful strategies or technical corrections simply because they are inconvenient.

Open source should mean more than publishing code.

It should also mean exposing the assumptions, limitations, evaluation methods and mistakes that influence the system.

Where the community can contribute

BLUM is open to contributions across many areas:

• financial reasoning models;
• open-source LLM integration;
• specialist agent development;
• market-data providers and normalization;
• temporal reasoning;
• technical-analysis validation;
• Forex, equity and ETF research;
• benchmark design;
• paper-trading infrastructure;
• leakage-resistant evaluation;
• uncertainty and confidence calibration;
• provenance-aware memory;
• frontend and data visualization;
• testing, documentation and code review.

You do not need to agree with the current architecture to contribute.

In fact, some of the most valuable contributions may come from demonstrating where the existing approach is wrong.

What BLUM is not

BLUM is not financial advice.

It is not a commercial signal service, a guaranteed trading strategy or a claim that an AI can already predict financial markets reliably.

It is an open research effort focused on a broader question:

Can a global open-source community build a financial AI system that is more transparent, testable and intellectually honest than the closed systems available today?

I do not think this question can be answered by one person.

That is why BLUM is open.

Explore the project

Hugging Face Space: https://huggingface.co/spaces/Italianhype/Blum

GitHub Repo: https://github.com/BlumFinancialLab/Blum

The project is under active development, and feedback is welcome at every level—from architecture and evaluation to models, UX and financial methodology.

The most useful response is not simply:

“This looks interesting.”

It is:

• What would you change?
• Where could the evaluation be misleading?
• Which component would you improve first?
• Which open-source model should BLUM support?
• What would make you trust—or distrust—its results?
• Would you contribute to an open financial AI project like this?

BLUM is not being built to ask the community for attention.

It is being opened because the project needs the community to become better.

Hi everyone,

Most financial AI systems are built behind closed doors.

You see the final prediction, the polished chart or the confident explanation—but rarely the data flow, the reasoning process, the evaluation rules or the failures that came before it.

BLUM is an attempt to build something different.

BLUM is an open-source financial AI research project developed publicly on Hugging Face and opened to developers, quantitative researchers, data scientists and anyone interested in building more transparent financial intelligence.

The ambition is not to create another black-box system that simply outputs:

BUY, SELL or HOLD.

The goal is to create an open ecosystem capable of collecting evidence, producing structured financial reasoning, testing its own conclusions over time and learning only from outcomes that can actually be verified.

Why open source?

Financial AI should not be shaped by one developer, one company or one model.

Markets are too complex, financial evidence is too fragmented and evaluation is too easy to distort.

A serious system needs different perspectives:

• quantitative researchers challenging the metrics;
• developers improving the architecture;
• traders identifying unrealistic assumptions;
• data engineers strengthening market-data pipelines;
• ML researchers testing models and evaluation methods;
• community members finding errors that the original developers missed.

That is the idea behind BLUM:

Build financial intelligence in public, improve it through open collaboration and make every important assumption open to challenge.

BLUM is not presented as a finished product.

It is a shared research foundation that the community can inspect, test, criticize, fork and improve.

What BLUM is building

BLUM combines a portable financial reasoning model with a broader modular research system.

Its architecture is being developed around several specialized capabilities:

• market scanning across equities, ETFs and Forex;
• technical and historical analysis;
• sentiment and news interpretation;
• bullish and bearish thesis generation;
• contradiction and risk detection;
• structured entry, stop and target plans;
• paper-forward trade validation;
• persistent learning from verified outcomes;
• benchmark-relative evaluation;
• transparent evidence and reasoning trails.

Instead of depending on a single model for every task, BLUM can use specialized agents for different parts of the research process.

A simplified flow looks like this:

Market data and external evidence
                ↓
Specialized research agents
                ↓
Bullish, bearish and risk analysis
                ↓
Central reasoning and synthesis
                ↓
Paper-forward decision
                ↓
Outcome measurement
                ↓
Validated learning and memory

The objective is not merely to generate a convincing financial narrative.

The objective is to preserve enough evidence to evaluate whether that narrative was justified.

Built to be challenged

BLUM is being designed around a principle that is often missing from AI demos:

A system should make it possible to prove that it was wrong.

For every decision, BLUM aims to preserve information such as:

• what evidence was available at that moment;
• which assumptions supported the thesis;
• which risks contradicted it;
• what would invalidate the decision;
• which entry, stop and target levels were proposed;
• how the market behaved afterward;
• whether the result was valid enough to enter the learning process.

This does not guarantee better predictions.

It creates a more transparent foundation for measuring whether the system is improving—or merely becoming better at sounding confident.

Current evaluation

The original MLX release was evaluated on a 53-example BLUM temporal-reasoning test and achieved:

• 96.26% aggregate task-contract score
• 100% structured validity
• 92.86% no-fabrication

These metrics evaluate BLUM-specific requirements such as structured output, temporal grounding and adherence to the task contract.

They do not demonstrate market-beating performance, general intelligence or trading profitability.

The portable release is also being prepared for independent evaluation through the Hugging Face ecosystem. Results will be published when they are externally available rather than predicted in advance.

Open development means open limitations

BLUM is still experimental.

Some components are mature enough to be tested, while others remain active research areas. Its paper-forward evidence is still limited, and no current result should be interpreted as proof of profitable trading performance.

This is intentional.

The project will not hide weak results, unsuccessful strategies or technical corrections simply because they are inconvenient.

Open source should mean more than publishing code.

It should also mean exposing the assumptions, limitations, evaluation methods and mistakes that influence the system.

Where the community can contribute

BLUM is open to contributions across many areas:

• financial reasoning models;
• open-source LLM integration;
• specialist agent development;
• market-data providers and normalization;
• temporal reasoning;
• technical-analysis validation;
• Forex, equity and ETF research;
• benchmark design;
• paper-trading infrastructure;
• leakage-resistant evaluation;
• uncertainty and confidence calibration;
• provenance-aware memory;
• frontend and data visualization;
• testing, documentation and code review.

You do not need to agree with the current architecture to contribute.

In fact, some of the most valuable contributions may come from demonstrating where the existing approach is wrong.

What BLUM is not

BLUM is not financial advice.

It is not a commercial signal service, a guaranteed trading strategy or a claim that an AI can already predict financial markets reliably.

It is an open research effort focused on a broader question:

Can a global open-source community build a financial AI system that is more transparent, testable and intellectually honest than the closed systems available today?

I do not think this question can be answered by one person.

That is why BLUM is open.

Explore the project

Hugging Face Space: https://huggingface.co/spaces/Italianhype/Blum

GitHub Repo: https://github.com/BlumFinancialLab/Blum

The project is under active development, and feedback is welcome at every level—from architecture and evaluation to models, UX and financial methodology.

The most useful response is not simply:

“This looks interesting.”

It is:

• What would you change?
• Where could the evaluation be misleading?
• Which component would you improve first?
• Which open-source model should BLUM support?
• What would make you trust—or distrust—its results?
• Would you contribute to an open financial AI project like this?

BLUM is not being built to ask the community for attention.

It is being opened because the project needs the community to become better.