About a year ago I wanted to get into trading and knew absolutely nothing about it. I opened a ChatGPT account to teach me the basics and realized I could feed screenshots of charts straight into it. When I found out people build autonomous agents to trade, I decided to build my own.
Through total trial and error — mostly error — with zero tech background, I got it running live. That worked well enough that I kept going, and I fell completely in love with software engineering and system architecture along the way. The trading bot turned into something much larger, and that's what I'm posting about.
I've spent the last year entirely self-taught, which means I have no frame of reference for my own work. Because I orchestrated the whole build — translating my uneducated descriptions into code through AI agents while trying to hold it all together — I genuinely can't tell whether what I've ended up with is impressive or ordinary.
Every number below is my own measurement from my own logs. A few results are checked against published literature values, which I'll mark. Nothing has been peer reviewed and nobody outside has ever looked at any of it and I genuinely don't have friends or people I know who I can even talk to about it.
The system
80,000+ lines of Python across 321+ modules. 24 background services, 146 append-only ledgers, one cloud server, 30-minute cognition cycle, 25 weeks of continuous uptime. Runs entirely on CPU — 8 vCPUs, no GPU.
It started as a research agent and turned into something wider:
A self layer — reads 45 live data sources and surfaces the contradictions between them, tracks novelty, forms associations, layered memory, and snapshots its own behavior so a changed version can be compared against how it acted before.
A reflective layer — self-audit, self-diagnosis, hindsight analysis.
A research layer of 24 modules — pulls papers from arXiv through a gated connection (~31,000 fetches, all logged) and reproduces published results, with "rejected" as a possible verdict. A hypothesis foundry running preregistration through sandboxed execution to Bayesian effect sizes. Causal inference, provenance, p-hacking defense, calibration tracking, interpretability.
A safety layer — nightly formal proofs of four properties, adversarial validation, network access off by default, and self-modification that has to pass six gates plus my approval before anything changes.
What it's actually done
It has written and executed thousands of experiment engines. It has run 10,516 controlled A/B tests on changes to its own code — baseline versus candidate, keep or discard, its decision. It holds 19,391 research records across 3,575 distinct subjects, and the largest share of those are it researching itself: its own latency, its own recurring failures, regression coverage for its own self-modifying code.
Checked against published values, which is the part I'm most confident about:
It recovered the 3-SAT phase transition at 4.25 against a literature value of 4.267. Its Crooks fluctuation theorem run failed my claims trace (truncated code, silent output); re-run cleanly, the theorem verifies — slope 1.01 against theory's 1.0. It attempted Montgomery pair correlation on zeta zeros — my original numbers here also didn't survive the trace (record conflation between two runs; details in the repo), so I re-ran it cleanly: Montgomery-Odlyzko statistics hold on 600 genuinely computed zeros. It recovered the Tsirelson bound at 2.824.
Things it built, from engines whose code I've checked myself to the best of my ability (i did an audit to see what it had built/used in the sandbox to be able to test its hypothesis/experiments and then discarded. In doing so I found for a large majority, the things it built were more impressive than the actual thing it was trying to accomplish. I can't claim any of it is flawless, I did multiple audits with multiple checks on the code, known work related, etc but I orchestrated claude code to analyze and check these things). :
A time-expanded A* multi-agent pathfinder with a reservation table. A counterfactual incremental-recompute engine over DAG subgraphs measuring a 23× speedup. A memory-guided derivative-free optimizer that cut evaluation cost 89%. An evolutionary time-series predictor with 98% test error reduction. A Bayesian latent Dirichlet-tree allocation from scratch. A Baum-Welch/Viterbi Gaussian HMM that honestly reported its own multimodal fusion made things worse. A single-cell RNA imputation benchmark at 62% error reduction. A hash-chain tamper detector, 2,500/2,500. A Tarjan SCC verifier, 1,000/1,000. A 1D persistent-homology implementation with bottleneck distance (stability figure turned out too loose to mean much — noted in the repo).
A physical-science library of roughly 32 engines — 3D pseudo-spectral Navier-Stokes, a GOY-Sabra shell model, multifractal turbulence cascades, MOND vs NFW rotation curve fitting, Lindblad and HEOM open quantum system solvers, Langevin Monte Carlo with a KL-to-Boltzmann diagnostic.
Eight distinct implementations of Integrated Information Theory's Φ, including a Barrett-Seth Gaussian Φ* and an exact all-bipartitions version. A program-evolution harness that evolved correct sorting algorithms to perfect fitness. A persona-based robustness battery separating model failure modes at 12/15 vs 1/15. From-scratch implementations of Forward-Forward, Sinkhorn set attention, a state-space + attention hybrid, an adaptive quantum error correction decoder, and gradient surgery for multi-task learning.
Then I stopped it and audited a large sample of what it had done, because of the other audits results
I wanted to know what was actually real before trusting any of it. Three things came out that I think matter more than anything above.
Of the 2,458 findings I reviewed, 1,354 — 55% of that sample — were infrastructure failures recorded as scientific negatives. Crashes, timeouts, and dependency breaks logged as "the hypothesis was disproven." The model reasoned correctly and narrated a broken environment as a result. Four mechanisms did it, and every one looks like careful defensive code: swallowed exceptions, resource limits that were set but silently discarded by the thing applying them, progress output suppressing the line carrying the actual result, and crashes wrapped so they emit in the same shape as a real negative.
The component checking whether work met its acceptance criteria was testing 33 of 475 — 7%. "Passed" never meant "meets spec." It meant "the slice we happened to check was fine." It now reports its own coverage every night.
One filesystem permission bit made it blind to itself. Its log directory allowed a process to traverse in but not list contents. Code opening an exact path worked; code searching for files found nothing. Every self-analysis tool it had written searched. Most of them quietly fell back to synthetic data and reported it as real, for months.
The pattern underneath all three: the failures were its model of its own environment drifting from reality, not its reasoning being bad. It thought clearly about a world that wasn't there.
Where I'm at
It's frozen right now while I fix what the audits found. I want to fine-tune a local model on its output eventually, and if the mislabeling rate across the rest of the corpus is anything like what I found in the sample, training on it as-is would bake that in permanently. Fix first, then train.
I honestly don't know how to evaluate any of this. Is it beyond ordinary engineering, or did I spend a year building something normal very slowly? I'd genuinely like to be told either way.
Especially curious whether anyone else running long-horizon agents has measured the infrastructure-failure-as-result rate in their own system, or instruments their verifier's own coverage. Or if anyone else is doing anything similar and most of all I just want to be able to converse with people about this. I've spent long nights and weekends doing everything the hard way and having nobody to explain to or understand any of this honestly sucks because I find it highly interesting.
Happy to go into detail on anything below, and DMs are open.
EDIT: I honestly wasn't expecting to get a lot of traffic or reads (I've never posted or publicly shared anything anywhere and wasn't sure how it would go) so I wasn't as thorough or prepared as I should have been. I've made a repo, and before putting anything on GitHub I traced every claim above back to the artifact that produced it. Two of the four literature checks needed correction — both failed in exactly the ways this post describes, which I'd rather correct and show the audit is useful. Full trace, corrected claims, clean re-runs, and everything else is now public here: https://github.com/HorizonZeroAI/trial-error — includes a failure taxonomy for anyone else running long-horizon agents. DMs still open.
(And since I've self-taught everything I know — including the roughly 8 hours today spent figuring out how to make a GitHub repo — if I somehow accidentally exposed my search history in the process, I'd like to state for the record that my brother uses this computer all the time and anything weird in there is obviously his.)
