API
Agora, Inc.
stock NASDAQ ADR

have been juggling the same thing – I’m on IBKR for the breadth, but I run a headless gateway in a docker container and wrap it with ib\_async so the API stays alive 24/7. if you just want MNQ micro‑futures, tradovate’s REST/WebSocket is the easiest to hook into a pure‑python stack, no desktop needed. for low‑margin, low‑latency runs AMP + rithmic via ninja or motivewave – just keep the account at the required idle balance. all in all, pick the ecosystem you’ll stick with longest to avoid battle‑between‑the‑Permission‑TBS‑quirks.

[public.com](http://public.com) especially if you trade options. They have a great options trading API and you get rebates for trading options with them

We log everything to a text file before we even think about hitting the API again, but that's for a construction inventory tool, not trading. The stakes with duplicate orders sound way higher than double-booking a pallet of rebar

I'd lean on client order IDs if the broker supports it, seems like the cleanest "don't screw me over" button. My gut says never trust a blind retry on a timeout, that's how you end up owning a warehouse full of lumber you didn't want

**Source:** [https://x.com/solana\_devs/status/2105586569264706021](https://x.com/solana_devs/status/2105586569264706021)
https://preview.redd.it/zvtsfk3uevsh1.png?width=680&format=png&auto=webp&s=dc992d3bc6be32b785eadae66822e2ff694c67be
This is a weekly newsletter on the latest Solana engineering news this week. If you want to stay updated on Solana tech every week, follow Solana Changelog at [@solana\_devs](https://x.com/solana_devs) and [@readylayerone](https://x.com/@readylayerone) and turn on notifications.
# Releases
Notable feature gates
Devnet - [Alpenglow](https://explorer.solana.com/address/A1pengvuM6JEcyNuTnMqepBKhwHE3N6PmUrdATGawhJS?cluster=devnet)
**New versions**
* Agave [v4.4.0-beta.0](https://github.com/anza-xyz/agave/releases/tag/v4.4.0-beta.0)
* Firedancer [Mainnet Release v26.09.5](https://github.com/firedancer-io/firedancer/releases/tag/v26.09.5)
* Superbank [v0.7.1-rc2](https://github.com/solana-rpc/superbank/releases/tag/v0.7.1-rc2) , [v0.7.0](https://github.com/solana-rpc/superbank/releases/tag/v0.7.0)
* Web3.js [v3.0.0-rc.1](https://github.com/solana-foundation/solana-web3.js/releases/tag/v3.0.0-rc.1)
* Kit [v8.4.0](https://github.com/anza-xyz/kit/releases/tag/v8.4.0)
* Stake Program [Rust SDK v5.1.0](https://github.com/solana-program/stake/releases/tag/interface%40v5.1.0)
* Memo Program [Legacy JS SDK v0.3.1](https://github.com/solana-program/memo/releases/tag/js-legacy%40v0.3.1)
* Token 2022 Program [Legacy JS SDK v11.1.0](https://github.com/solana-program/token-2022/releases/tag/program%40v11.1.0)
* LiteSVM [v0.17.0](https://github.com/LiteSVM/litesvm/releases/tag/v0.17.0)
# Ecosystem work
SIMDs
* A discussion was started to modify the Application Binary Interface (ABI) v1 to [use registers r3-r5 as the place to load instruction pointers and metadata](https://github.com/solana-foundation/solana-improvement-documents/discussions/672) WTM (what this means) - An ABI defines where crucial data sits in memory as instructions within your transaction are being processed. The discussion is about using three reserved places in memory (the registers in the proposal) to store crucial data about the size of the instruction accounts and data and where they are located. Doing this allows for programs to do lookups instead of copying data from memory region to memory region, which is the much slower way the runtime does this today.
* A proposal was made to make CPIs on the runtime [saner and more performant](https://github.com/solana-foundation/solana-improvement-documents/pull/670) WTM - Calling other programs on Solana requires a syscall (a specified operation on the runtime with a well-defined behavior and cost) that stores redundant account information in memory and transforms that information only to be transformed back again during processing. The change proposed here removes both the unnecessary transformation step and the duplicated memory allowing for runtime and space allocated to run an instruction.
* An [additional data field in the Vote Account for commission history](https://github.com/solana-foundation/solana-improvement-documents/pull/677) was proposed WTM - Vote Accounts serve as the identity of validator nodes that support the network and contain information about stake, rewards and commissions. Changes will be made during Alpenglow that replace some of this information for the current epoch. This proposal restores that information in the Vote Account.
* Adding [location information to the Vote Account](https://github.com/solana-foundation/solana-improvement-documents/pull/674) and [making the leader schedule take geography into account](https://github.com/solana-foundation/solana-improvement-documents/pull/675) during assignment was proposed WTM - The Leader Schedule defines when each validator node gets to build blocks during an epoch. This is usually determined randomly and the more stake a validator has, the more slots in an epoch it gets allocated to be leader and thus receive rewards. The benefit of making the leader schedule geographically-aware would be that users of the network have a greater chance of sending their transactions to a leader closer to that part of the world. See this visualization by [@TheWattenhofer](https://x.com/@TheWattenhofer) to see how leaders span the globe more broadly once this proposal is implemented:
[https://x.com/solana\_devs/status/2105586569264706021](https://x.com/solana_devs/status/2105586569264706021)
https://preview.redd.it/j3phedv2fvsh1.png?width=556&format=png&auto=webp&s=2e8cc3ce22b67bb0084ba4483041ef8c2a51ba2e
Validator clients (Agave, Firedancer, Mithril)
* Agave plans to [expose the Alpenglow rank map](https://github.com/anza-xyz/agave/pull/15654) in its RPC methods API WTM - The RPC API allows validator operators to peer into the state of the network while operating. This change allows validator operators to serve the read layer (streaming service meant to push events to subscribers) giving them updates on the votes from vote accounts with a given certificate. Vote transactions are being removed from transactions and so votes by individual validators need to be parsed out from the certificates that are onchain.
* [Improvements to shred ingest latency](https://github.com/anza-xyz/agave/pull/15638) are being worked out in Agave WTM - The change described prioritizes shred ingest (receiving block data from the leader) over shred repair (requesting missing or broken block data from other validators). This approach gives more space for blocks to be received by non-leader nodes so that repair becomes more of a last resort.
* Contention on replay hashing and verifying [is being reduced](https://github.com/anza-xyz/agave/pull/15656) in Agave WTM - This change, like in the previous Changelog, is a more judicious use of the jemalloc arenas to allocate memory for easier use again for threads. In this case, it’s for the handoff between the hash and verification threads within the the replay service.
* More work to replace rayon with [custom threadpooling](https://github.com/anza-xyz/agave/pull/15585) is being implemented in Agave’s retransmit service WTM - Rayon is an off-the-shelf Rust crate that allows developers to create worker thread pools. Agave has found this to use more memory and compute than is actually required. A work-stealing pattern where jobs are placed in a queue and threads pick the jobs up on their own was used in other places of the Agave stack and is being used as a performance improvement in the Retransmit service as well.
* Agave is [improving its slot repair service](https://github.com/anza-xyz/agave/pull/14761) WTM - Repair is responsible for requesting missing shreds for a block from other validators in order to complete its own block for replaying and voting. This change is a simple optimization that skips attempting repair on slots whose shreds are already full (i.e. no shreds are missing). This is a relatively low-hanging optimization since it is work that no longer needs to be done.
* Airdrop on the Solana CLI will [link to the Solana web faucet](https://github.com/anza-xyz/agave/pull/15532) WTM - Airdrops are no longer supported on the Solana CLI and are only done today through the [faucet.solana.com](http://faucet.solana.com/) website. This change communicates this to users so that receiving test SOL on Testnet and Devnet becomes understood much more easily.
**RPC 2.0**
* Superbank is preparing its [Alpenglow implementation](https://github.com/solana-rpc/superbank/pull/99) WTM - An RPC is also an interface to validator stake and vote information. This change prepares Superbank as part of the RPC/read layer to serve requests to users related to Alpenglow primitives.
**Solana language clients (Web3.js, Solana Kit, Kit plugins, Solana SDK, Codama, Solana Go)**
* [Seed length validation for PDA derivation](https://github.com/anza-xyz/solana-sdk/pull/971) is being added to the Solana Rust SDK WTM - Seeds serve as inputs to derive a program account address used to hold program state, etc. This change allows for additional checks before seeds are added as input to a helper function that derives a corresponding address.
**Solana Program Library (SPL) and Core BPF**
* The ed25519-programmatic-signer program will [use V1 transactions exclusively](https://github.com/solana-program/ed25519-programmatic-signer/pull/60) WTM - Since the programmatic signer programs use a lot more cryptography, they will require a lot more transaction bytes to store the operations and execute. Using V1 transactions gives them the right space by default.
Solana program frameworks (Anchor, Pinocchio, Steel, Quasar)
* Caravel is [adding token program CPIs helper instructions](https://github.com/joeymeere/caravel/pull/23) WTM - Token Program helpers are standard in every program framework implementation. Caravel supporting these would make it more in line with other program frameworks like Anchor.
# Other interesting things
* [@accretion\_xyz](https://x.com/@accretion_xyz) wrote an essay about bugs program devs miss when upgrading their state accounts
[https://x.com/accretion\_xyz/status/2105338273216221416](https://x.com/accretion_xyz/status/2105338273216221416)
https://preview.redd.it/mgj6h1g7fvsh1.png?width=559&format=png&auto=webp&s=c4d6867b4d8682219be04592c67dc16219d581ba
* [@SteveCleanBrook](https://x.com/@SteveCleanBrook) hosted a Pirates Parley episode with the CEO of [@asymmetric\_re](https://x.com/@asymmetric_re), [@claudijd](https://x.com/@claudijd)
[https://x.com/SteveCleanBrook/status/2105559469375520853](https://x.com/SteveCleanBrook/status/2105559469375520853)
https://preview.redd.it/vyjnu8wafvsh1.png?width=561&format=png&auto=webp&s=af9080460d5c3ccc017c9ef35ed603b223afbe97
* [@TheWatterhoffer](https://x.com/@TheWatterhoffer) published an article about efforts to reduce latency by switching to Alpenglow
[https://x.com/TheWattenhofer/status/2105295508377944454](https://x.com/TheWattenhofer/status/2105295508377944454)
https://preview.redd.it/5p9msleffvsh1.png?width=554&format=png&auto=webp&s=77cdde841ce0917a53d21a40cbf65aa48a7b0993
* [@SolanaFnDn](https://x.com/@SolanaFnDn) and [@anza\_xyz](https://x.com/@anza_xyz) released a whiteboard session explaining how Alpenglow works
[https://x.com/solana\_devs/status/2104577640334278826](https://x.com/solana_devs/status/2104577640334278826)
https://preview.redd.it/ew51megifvsh1.png?width=561&format=png&auto=webp&s=f1f17c6278e24816cc461693dff10cecf9e045a9
* [@clairefxyz](https://x.com/@clairefxyz) published an article on her efforts to optimize compilation using error handling in p-token as an example
[https://x.com/clairefxyz/status/2104220602227655014](https://x.com/clairefxyz/status/2104220602227655014)
https://preview.redd.it/aza8cikkfvsh1.png?width=563&format=png&auto=webp&s=3eec4d7845926d3a6be8eabb53cc77e8fc0d8289
* A new wallet CLI app was open sourced on Github [https://github.com/ax-x2/solx](https://github.com/ax-x2/solx)
https://preview.redd.it/ahpw78dmfvsh1.png?width=680&format=png&auto=webp&s=7bd6486c52146e4b0e9d2b5a1724078db3c89835
* [@0xnaga](https://x.com/@0xnaga) launched a site talking about MEV strategies on Solana
[https://x.com/0xnaga/status/2103126095885390299](https://x.com/0xnaga/status/2103126095885390299)
https://preview.redd.it/uow3datpfvsh1.png?width=559&format=png&auto=webp&s=f66cda54852fc7d222d7d6c5efc735868cb541f1

If you made the data layer non-specific to IBKR, it would be interesting to interface the Tradier Option API to it. If it was python I would do it in a flash,. The Tradier API is super easy to use and essentially free.

Ja, die Budgetierung ist ein anderer Ansatz, lässt sich aber auch abschalten.
Bei der Banksynchronisierung bin ich mir unsicher, ob da nur Lesezugriff angefordert wird, bzw. ob Banken es überhaupt unterstützen, feingranulare Rechte anzufordern (also nur Lesezugriff). Grundsätzlich würde es aber die verwendete Enable Banking API wohl ermöglichen, Transaktionen auszulösen, auch wenn Actual das nicht verwendet.

A lot of you asked how I set this up after [my last post](https://www.reddit.com/r/ai_trading/s/51GUpeRX2T), so here's the full walkthrough. This is the architecture, not the engine. My actual rules are proprietary, but this gets you to the starting line.
**What you need**
**•**Robinhood account with agentic/API access enabled (Account → Settings)
**•**Claude Code installed (claude.ai/code) — this is Anthropic's CLI, not the web chatbot
**•**A dedicated folder on your computer for your trading files
**Step 1 — Connect the MCP**
This is the one line that makes everything possible. Run this in Claude Code from your trading folder:
claude mcp add robinhood-trading --transport http [https://agent.robinhood.com/mcp/trading](https://agent.robinhood.com/mcp/trading)
Claude can now check positions, get quotes, place orders, set stops, and cancel orders through a conversation. Verify it worked by asking "what's my account balance?" in a new session.
**Step 2 — Pick your sectors and build your watchlist manually**
This part is on you. Claude doesnt randomly scan the whole market — you tell it which sectors and themes you believe in and you curate the tickers yourself. Pick 2 or 3 sectors max. Stay in your lane. Claude then monitors those names during scans not the entire market.
The adjacency matters too. If youre watching one sector think about what moves with it. You build that logic yourself and feed it in. This is where your conviction lives — Claude executes it it doesnt replace it.
**Step 3 — Write your rules in** [**CLAUDE.md**](http://CLAUDE.md)
Create a [CLAUDE.md](http://CLAUDE.md) file in your trading folder. Claude loads this automatically in every session. Define at minimum:
**•**Position sizing
**•**Entry criteria
**•**Stop-loss percentage
**•**Profit targets and how you scale out
**•**A no-chase rule
**•**An explicit autonomy grant — tell Claude it can execute trades without asking permission first
The autonomy grant is non-negotiable. If Claude has to ask you before every trade youve built a chatbot not a system.
**Step 4 — Start a trading log**
Make a logs/ folder. Each day gets its own file. Claude writes to it during scans and reads it before each new one — this stops it from re-analyzing tickers it already rejected earlier in the day.
**Step 5 — Run manually first**
Run sessions by hand for at least a week before automating. Open Claude Code and say something like "screen my watchlist for setups, check my positions, execute anything that qualifies." Watch what it does. Fix your rules when it makes a bad call. Dont automate until you trust the rules.
**Step 6 — Set up scheduled scans**
Claude Code has a scheduled tasks system. Once your rules are solid, create scan agents that fire throughout the day: pre-market, market open, mid-morning, midday, power hour, close. Each one runs your rules against live data and acts automatically.
**Step 7 — Build your memory**
There's a persistent memory system at \~/.claude/projects/\[your-dir\]/memory/. Write memory files for lessons learned, rule refinements after bad trades, and known account limitations. Every future session loads these automatically — the system gets smarter over time.
**What I'd tell myself at the start**
Rules over gut. When you want to override mid-trade, update the rule for next time instead.
Audit live positions directly, not just the log. The log can miss trades from interrupted scans.
Whole shares only. Fractional shares break stop-loss orders on some account types.
The biggest unlock is autonomy. A system that checks with you on every trade isnt autonomous. Trust your rules or fix your rules but dont half-commit.
Compounding is slow. +5% in a quarter on $2k isnt impressive in dollar terms. The rules and the system youre building are the actual asset.
Not financial advice. This is an experiment with a small account, and results aren't guaranteed. Only trade money you can afford to lose, and test with manual sessions before you automate anything.

Hey bro, so it runs natively within MotiveWave itself which is why it’s such a great option. Zero latency that would be unavoidable with an API based setup. The best part is I trade it through Lucid Trading Props so it is absolutely free beyond the eval fees.

**The EURe/frxUSD pool is live on Uniswap v3 on Polygon Chain, giving Monerium's regulated euro token a direct route into dollar liquidity for stablecoin payments and treasury apps.**
Moving money across borders often means changing currencies. With this pool, a payment app on Polygon Chain can build that exchange into the transfer instead of sending users elsewhere. An eligible Monerium customer sends euros by SEPA to a named EUR IBAN, Monerium issues EURe into the linked wallet, and the customer can swap it for frxUSD through the pool. Uniswap v3 provides the exchange infrastructure and Polygon settles the swap.
Each partner covers a piece. EURe is a MiCA-compliant e-money token backed 1:1 by safeguarded euro reserves. frxUSD is a dollar stablecoin backed by cash-equivalent reserves, including tokenized U.S. Treasury funds. Capa, a stablecoin FX and cross-border payments provider, helps support liquidity and generate payment flows and FX activity.
* EURe/frxUSD is live now on Uniswap v3 on Polygon Chain
* Low network fees make smaller, frequent exchanges practical
* Fast finality lets an app confirm a completed trade in seconds
* Monerium's API handles onboarding, issuance, redemption and euro payments
A wallet could let customers convert part of a euro balance into dollars. A treasury app could rebalance euro and dollar holdings in one product. Payment providers can connect the onchain exchange to bank accounts, and bank transfers remain separate steps with their own processing times. frxUSD is also the dollar pairing in other FX pools on Polygon, which gives builders a starting point for routes into more currencies.
Full post: https://polygon.technology/blog/monerium-eure-frxusd-onchain-fx-pool

That's sweet! I'll check yours out too! I had import for a while and lockout but it defeated the whole value prop for the discipline side. Totally get the some having it tho, it is super helpful. Also was able to make it inexpensive without paying an API fee. Had a great team help on it, let me know what you think! Excited to check yours out!

This situation differs from databases for a few reasons though:
- Oracle wasn't swimming in hundreds of billions of unrealized losses that I needed to find a way to recoup. So a smaller potential market simple meant lower profit and wasn't an existential crisis for the firm.
- Databases are huge, sticky infrastructure that requires moving mountains to migrate from. But LLM companies have made their product so seamless to use that it's just an API endpoint. For a great visual example, go make a
Databricks Community Edition account (free account)
 and build an agent endpoint in the point and click UI. Then swap out the agent with a different LLM with the press of a button. It probably takes leas than 15 seconds.

I’m trying to understand the real-world cost of running a personal automated futures strategy on CME markets, and I’m wondering if anyone here has gone through the same issue.
My intended setup is fairly simple:
CME real-time market data → Rithmic or broker API → Python → signal generation / automated execution
I’m a non-professional individual trader trading only my own account.
I also want to keep a graphical trading platform open for discretionary trading and monitoring, so ideally both:
my Python application and the graphical platform
would receive the same CME market data without requiring two separately billed market-data subscriptions.
The part that surprised me is the CME Non-Display licensing.
From the current CME fee schedule effective June 1, 2026, I can see categories such as:
• User Non-Display Category A
• Managed User Non-Display Category A
and the fees appear potentially significant for a small individual trader.
I have contacted both EdgeClear and Ironbeam directly and am waiting for clarification on how they classify this specific setup, but I would be very interested in hearing from anyone who has actually implemented something similar.
A few questions:
1) If you run your own Python/C++/Java application that consumes real-time CME market data and automatically trades your personal account, are you actually being charged CME Non-Display fees? If yes, which category are you under and approximately how much are you paying per month?
2) Does the situation change if the application only processes real-time data and generates signals, while orders are entered manually?
3) Has anyone managed to use one CME market-data subscription for both an API application and a graphical platform, particularly with Rithmic?
4) If you originally planned to build a direct API-based algo but found the fixed CME/API costs too high, what did you end up doing instead?
For context, Ironbeam has currently quoted me:
native Ironbeam API:
1) no API fee if certain balance/activity requirements are met;
2) Rithmic API connectivity: $100/month;
3) Rithmic market data: $15.50 per exchange;
but I am still waiting for clarification regarding Non-Display licensing and simultaneous API + graphical-platform market-data access.
My concern is not really the technical side — Python/Rithmic/API connectivity is feasible.
The issue is If a retail trader has to pay something like:
API/connectivity + CME market data + $200–$450+ Non-Display licensing + platform costs
every month before even knowing whether the strategy has a sustainable live edge, the fixed-cost hurdle becomes quite significant.
I’m particularly interested in first-hand experiences, especially from individual systematic traders using CME futures
Thanks everyone!!!!

Excel API Wrapper for C++ in 2026 ?

Alpaca API covers news, and this is a free setup. There are some good questions worth looking up. I anticipated this and created the strategy knowing that Bloomberg Terminal will always be faster.

How do you prevent duplicate orders when a broker API times out?

Alpaca is pretty much the go-to if you're routing TradingView webhooks for US stocks. API is solid and rate limits are reasonable.
I use them for my setup through Kronos Trading, signals fire straight into Alpaca via webhook and fills are usually clean.
That said, if you're running a true high-frequency scalping strategy, webhooks down to a retail broker API might still give you some slippage compared to direct execution. Works fine for swing/intraday stuff thoughh!

85% margine on API btw.

it's basically the HTTP for machine payments, just a standard way for any client to pay for API access on the spot

u/Chuu I benched this when it first released, it was in the order of 100-200 ns without warm-up send() and 300-400 ns with it, so a bit worse than SFN's own benchmarks (see Davor Frank's June 2017 presentation, "TCPDirect, sfptpd and ANTS").
The comparison isn't trivial since TCPDirect's API differs from BSD sockets in some ways: epoll for TCPDirect supports edge triggering but not level triggering, and TCPDirect stacks aren't thread-safe.

One more question, because you seem to have thought about this much more deeply than most people discussing PIT data.
If you were building an adversarial validation test for an S&P 500 daily constituent dataset covering roughly Mar–Sep 2026, what are the 3–5 tests you would run that are most likely to expose hidden backfilling or timing leakage?
Also: are you speaking from experience with a particular data vendor/API, or is this based on general PIT/data-engineering knowledge?
If you can name even one public dataset/vendor that you believe genuinely preserves historical knowledge-time rather than merely historical effective-time, that would give us a very concrete lead to investigate.