LLM Budget Forge

Alexis Majorel — Tue, 21 Apr 2026 16:59:01 +0000

Here is the English version of the article, optimized for a tech audience (GitHub, LinkedIn, or a technical blog).

Stop the Bleeding: Take Control of Your LLM Costs with LLM BudgetForge
For any developer or startup building with AI, the scenario is painfully familiar: you launch a project using OpenAI or Anthropic APIs, only to wake up to a massive, unexpected bill. Whether it’s caused by a runaway loop, inefficient prompts, or high-volume usage of premium models like GPT-4o or Claude 3.5 Sonnet, costs can spiral out of control in hours.

This is exactly why LLM BudgetForge was built.

What is LLM BudgetForge?
LLM BudgetForge is an open-source, self-hosted proxy that sits directly between your application code and your LLM providers (OpenAI, Anthropic, Google).

Think of it as a smart "financial firewall" for your AI development. It monitors your consumption in real-time and enforces strict budgetary rules that you define.

Key Features to Protect Your Bottom Line
Unlike basic monitoring tools, BudgetForge offers active management to ensure your services stay online without breaking the bank:

Strict Per-Project Budgets: Set a hard limit for each project. Once the cap is hit, the proxy blocks further requests to prevent overages.

Automatic Downgrading (Model Fallback): Perhaps the most innovative feature—if your "premium" budget is exhausted, BudgetForge can automatically reroute calls to a cheaper model (e.g., switching from GPT-4 to GPT-4o-mini) to maintain functionality at a fraction of the cost.

Slack & Email Alerts: Stay informed with instant notifications when you hit 50%, 80%, or 100% of your allocated budget.

Usage Dashboard & CSV Export: Visualize your spending patterns and export data for deep-dive analysis or accounting.

Team Management: Manage multiple team members and project keys from a single, centralized interface.

2-Line Integration
One of the best parts of LLM BudgetForge is how non-intrusive it is. You don't need to rewrite your business logic. Just swap your API key and update the base URL in your existing client.

Example in Python:

Python
from openai import OpenAI

Seamless integration via the BudgetForge proxy

client = OpenAI(
api_key="bf-your-project-key",
base_url="https://your-instance/proxy/openai"
)
The Power of Open Source & Self-Hosting
Because LLM BudgetForge is free and self-hosted, you get the best of both worlds:

Privacy & Security: Your API keys and request logs never leave your infrastructure.

Zero Middleman Fees: You don’t pay a subscription fee just to manage your costs.

Complete Customization: Modify the code to fit your specific enterprise workflow.

Ready to Forge Your Budget?
Stop letting API bill anxiety stifle your innovation. Join the community, try the tool, and take back control of your AI spending.

Live Demo: https://lnkd.in/dPhRhcQM

GitHub Repository: https://lnkd.in/dJb4jP6R

How I aggregate 5 price sources into one confidence-scored feed for AI agents

Alexis Majorel — Mon, 20 Apr 2026 14:26:11 +0000

Most AI agents that need market prices do the same thing: call one API, trust the number, move on.
That works until it doesn't.
A single source going stale, returning a wrong price during a flash crash, or simply being down — and your agent acts on bad data with no way to know.
I spent several months building MAXIA Oracle to fix this. Here's the architecture and what I learned.

The core idea: confidence over precision
The insight that drove the design: an agent doesn't need the "perfect" price. It needs to know how much to trust the price it got.
Every response from MAXIA Oracle returns three things:
• The median price (cross-validated across sources)
• A confidence score (0–100)
• An inter-source divergence percentage
If Pyth says BTC is $83,000 and CoinPaprika says $83,150, confidence is high (95), divergence is low (0.18%). The agent can act.
If one source returns $80,000 and another $86,000, divergence spikes. The agent should pause and flag the discrepancy before executing anything.

The 5 sources and why each one matters
1. Pyth Network (Solana)
Pyth is the backbone. A single batch call to the Hermes HTTP API returns prices for up to 79 symbols in one round-trip — crypto majors, Solana ecosystem, US equities (AAPL, TSLA, NVDA), forex pairs, stablecoins.
Each Pyth response includes a confidence interval and an expo field for precise decimal handling. The freshness check is critical: Pyth updates every 400ms on-chain, but if you're calling the REST API, you can get a cached value. I enforce a max staleness of 10 seconds.
Pyth batch call — 79 symbols in one HTTP round-trip
ids = [PYTH_IDS[sym] for sym in symbols if sym in PYTH_IDS] resp = await client.get( "https://hermes.pyth.network/v2/updates/price/latest", params={"ids[]": ids, "parsed": "true"} )
1. Chainlink (Base mainnet)
Chainlink is the independent verifier. It runs on a completely different infrastructure (EVM on-chain vs Solana), so a Pyth anomaly won't affect it.
I call Chainlink via a direct RPC call to Base mainnet, reading the latestRoundData() function from each price feed contract. No intermediary, no API key — pure on-chain data.
Direct on-chain read — no API key needed
result = contract.functions.latestRoundData().call() price = result[1] / 10**decimals updated_at = result[3] # Unix timestamp of last update
The downside: Chainlink covers ~30 symbols on Base, so it can't verify everything. But for the major assets it covers, it's the most trustworthy cross-check available.
1. CoinPaprika
CoinPaprika covers altcoins and memecoins that Pyth and Chainlink don't list. It's also useful as a CeFi reference — it aggregates exchange data, so it reflects what centralized markets are trading at.
1. RedStone
RedStone fills the gaps between Pyth and CoinPaprika for DeFi-native assets. It also provides an alternative data path for some Pyth symbols, which is useful for divergence detection.
1. Uniswap v3 TWAP (Ethereum mainnet)
The TWAP (Time-Weighted Average Price) from Uniswap v3 pools is manipulation-resistant by design — it's computed over a time window, so flash loan attacks can't spike it artificially. For high-value DeFi assets where on-chain trading volume matters, this is a strong signal.
I use a 10-minute TWAP window and only include pools with at least $500k liquidity. Out of 8 pools I tested, 3 met this threshold with acceptable spread vs reference prices.

The aggregation cascade
The logic runs in priority order:
1. Pyth batch call → covers ~79 symbols
2. For each symbol NOT in Pyth → try Chainlink on-chain
3. For remaining gaps → CoinPaprika / RedStone
4. Uniswap v3 TWAP → parallel call, used as verification layer
For each symbol with multiple sources, I compute:
prices = [p for p in source_prices if p is not None] median_price = statistics.median(prices) divergence_pct = (max(prices) - min(prices)) / median_price * 100 confidence = compute_confidence(prices, divergence_pct, freshness)
Confidence is penalized by: high divergence, stale data, single-source results, known circuit breaker trips.

What surprised me
1. Pyth's confidence interval is underused. Every Pyth price comes with a ±conf value in the same units as the price. Most projects ignore it. I use it to weight Pyth's contribution in the aggregation — a tight confidence interval increases Pyth's weight.
2. On-chain is not always fresher. Chainlink updates on deviation threshold + heartbeat. For low-volatility assets, the on-chain price can be hours old. I always check updatedAt and reject stale answers.
3. Uniswap pool selection is the hard part. Finding pools where the TWAP is reliable took more work than the aggregation itself. Many pools have low liquidity, wide spreads, or are dominated by one LP. I ended up with only 3 pools I trust.

Integration
The MCP server runs at https://oracle.maxiaworld.app/mcp/sse — drop it into Claude Desktop, Cursor, or any MCP client and your agent can call get_price("BTC") natively.
Python
pip install maxia-oracle
TypeScript
npm install @maxia-marketplace/oracle
Free tier: 100 req/day, no signup
curl -X POST https://oracle.maxiaworld.app/api/register
91 symbols. Price history (24h/7d/30d). Alerts with webhooks. SSE streaming. Pay-per-call via x402 micropayments ($0.001 USDC on Base) for agents without API keys.

Happy to answer questions about the aggregation logic, the on-chain read setup, or the x402 payment flow.
Source: https://github.com/majorelalexis-stack/oracleforge

DEV Community: Alexis Majorel

LLM Budget Forge

Seamless integration via the BudgetForge proxy

How I aggregate 5 price sources into one confidence-scored feed for AI agents