The next thing for Tyler to do after moving VaultX to a server was to start working on the sub-program.
What he intended to create was an arbitrage sub-program. It was almost similar to VaultX, but closer in design to the bots used by HFT firms.
The bot would operate as a low-latency, autonomous sub-program designed to detect and exploit triangular arbitrage opportunities across global financial markets.
It would track price discrepancies between three currency or commodity pairs—like USD/EUR → EUR/JPY → JPY/USD—across multiple exchanges in real time.
The concept was simple in theory but required precise execution in practice:
Detect a price loop where converting from A → B → C → A returns more than the starting amount.
Execute all trades simultaneously using Tyler's funds.
Lock in fractional profits before the prices self-correct—usually within milliseconds.
But Tyler's bot wasn't theoretical. It was built using the specialized Financial Mathematics knowledge from the system.
Its internal architecture could parse millions of quote combinations per second, filter latency-sensitive loops, and commit trades across decentralized exchanges with near-zero lag.
How does the sub-program work?
Market Scan Engine: Continuously fetches real-time pricing from 20+ global exchanges across forex, commodities, and crypto markets (including illiquid pairs with lagging updates).
Loop Validator: Calculates net yield for every triangular loop after transaction costs, latency delays, slippage, and FX spreads are accounted for.
Execution Engine: Routes the trades simultaneously to each exchange using pre-authenticated API connections. It ensures atomic execution—either all trades go through, or none do—using conditional order batching.
Risk Buffer Module: Filters out trades with profit margins under 0.02%, since market conditions may change mid-execution.
Session Manager: Each instance of the sub-program is tied to one account, capped in execution rate and risk to avoid triggering exchange-side compliance flags.
Yes, those damn regulatory flags again.
But it was all good. Given that Tyler was using system-enhanced specialized knowledge, his bot wasn't bound by the usual limitations of 2010 technology.
It could operate with sub-millisecond execution times.
It used predictive volatility mapping—not just simple price checks.
It handled dozens of arbitrage types, not just triangular (e.g., latency arbitrage, spread compression, cross-asset anomalies).
This put the bot on par with—or better than—the elite quant firm infrastructure of the future.
And since he had already resolved the hardware bottleneck using a dedicated server, his bot could now:
Operate 24/7 without client-side lag
Pull multi-exchange data feeds without throttling
Maintain multiple live order books in memory
In real-world trading, profits are limited by spread, liquidity depth, execution costs, and slippage.
But Tyler's system could dynamically scale trade sizes and cancel or re-execute trades in real time. This drastically reduced those constraints.
This also meant that the sub-program would earn big for Tyler—as long as he had enough capital.
And this is where the difference between VaultX and the sub-program became clear. VaultX could make as much as Tyler wanted, even with relatively modest capital.
But the sub-program couldn't do that. Normal arbitrage trading required a significant amount of capital to earn significant money.
The sub-program was no different. If Tyler wanted to earn serious profits using it, he would need a sizable amount of capital—at least $1 million.
But the current Tyler couldn't raise that kind of money. And because of the compliance flags, even $10,000 was still beyond his reach.
While Tyler couldn't raise the massive funds he needed just yet, he could still manage with what he had.
And since the sub-program required multiple trading accounts to operate, he planned to ask David to create more for him.
According to his knowledge, there were three additional trading platforms that supported API integration.
Tyler would have David open accounts on those platforms and deposit a minimum of $2,500 into each.
Yes, the amount was nowhere near the recommended $1 million per account, but it would have to do for now.
And with that setup, the sub-program could generate an average of $18,000 per month per account.
Scaled across four accounts—his current one and the three new ones—that would bring in a total of $72,000 a month.
And all of it would still be under the radar, at least for the first month.
Yes, the first month. Tyler planned to use that time to build trust and history on the accounts. Once that was done, the risk of triggering regulatory flags would drop significantly.
Since both the trading and bank accounts were (and would be) created using David's information, that already solved part of the problem.
But even after the first month, it didn't mean Tyler could do whatever he wanted.
He couldn't have VaultX and the sub-program pulling in tens or hundreds of thousands of dollars daily—but doing it once or twice a month? That was manageable.
All of that, however, would change once his LLCs were ready. After that, he wouldn't have to worry about regulatory flags nearly as much.
Tyler already had everything about the sub-program mapped out, and it was finally time to start coding it.
He glanced at the time on his laptop. Just a little past noon.
He had about an hour or two before he needed to leave to pick Devin up from school, and he intended to finish the initial build before then.
Sliding into his seat, he cracked his fingers and opened the IDE. His laptop wasn't laggy anymore after he transfered VaultX to a server.
"Let's call you VaultPrime," he muttered, naming the sub-program after his first project.
He created a new directory inside VaultX's folder, titled vaultprime_core, and initialized the repo.
He started with the engine skeleton—thread pool handler, logging system, error protocols. Each component was modular, written to scale, and optimized for lightweight memory usage. Every function was laced with precision and purpose.
He didn't have the luxury of sloppiness.
Next, he wrote the Arbitrage Detection Module—the heart of the sub-program. This function scanned global FX pairs and commodity tickers in real-time, feeding data into a latency-optimized pipeline.
If the price gap met or exceeded 0.03%—his current threshold—it would flag the trade.
Then came the Execution Layer.
This part was critical. Each trade had to be executed simultaneously across three platforms, with sub-second precision. If even one leg lagged, the profit would collapse—or worse, he'd take a loss.
He built in a failsafe: any triangle that couldn't be executed within 250 milliseconds of signal confirmation would auto-cancel.
"If it's not fast, it's dead." That was the core philosophy of VaultPrime.
Tyler moved next to Risk Management—capital allocation per trade, maximum daily volume, anti-flag mechanisms.
He coded hard limits into the system to prevent sudden surges that might raise red flags with compliance bots.
Last came the Anonymized Relay Layer—a shell process that routed trade signals through encrypted proxies.
VaultX would interact with VaultPrime through internal pings, with Tyler having full override access via SSH.
The whole design was sleek, lightweight and powerful. Meant to be invisible, silent, and consistent.
By the time Tyler typed out the last block and saved the file, he saw that it was almost time to go pick Devin from school.
1:41 PM.
"Not bad," he muttered, saving everything and compressing the project folder.
VaultPrime had been created and was ready to run. All he needed now were the three trading accounts he would ask David to create for him.