Data lineage, validation gates, operating cadence, and the architecture that keeps one wrong number from compounding into a bad decision. Built to be inspected, not taken on faith.
The filing is the data — the 10-K, the transcript, the footnote. Nothing is trusted from a single source.
Price works the same way. Only the close matters, captured within minutes of it — not the noise in between.
U.S. fundamentals come straight from the primary regulatory filing. Markets without an equivalent filing regime use a general-purpose market-data provider — but only for screening. That data is never the basis for a thesis: fresh figures are sourced directly from the company itself before any thesis is written, so a screening-stage gap never reaches a decision unchecked. Where a figure can't be reached from the automated sources — insider ownership, for U.S. tickers — it's excluded from scoring rather than estimated, then sourced directly from the proxy filing at research stage. A known gap is worth more than a convenient guess.
A wrong number caught once and fixed once will happen again somewhere else. Every correction here is traced to its root cause, checked for every other place the same mistake could occur, and closed off with a rule that prevents the whole class of error — not just the instance that got noticed.
Not just what was wrong, but why the system produced it — traced to the specific step, rule, or assumption responsible.
Every other record that could carry the same error is checked, not just the one a person happened to notice.
The fix is written back into the process itself, so the same class of error can't recur silently.
Applied the same way whether the error is a mispriced trigger, a mislabelled metric, or a process that stalled and should have resumed on its own.
Every numeric claim is checked against the source document it's attributed to before a report is finalized — not spot-checked after the fact.
Disagreements between independent functions are surfaced, not smoothed over. A quiet, immediate consensus is a reason to look closer, not a green light.
A process that stalls partway through resumes automatically from where it left off, rather than quietly failing and going unnoticed.
The parts that don't show up in a report are what make the reports possible: a system of record for every decision, a workflow layer that gives every task and correction a durable history, and infrastructure that's encrypted and monitored the way any production system should be.
A queryable record of every company's current status, decision history, and pricing data — not a folder of documents that drifts out of sync with reality.
Every research task, correction, and incident has an auditable lifecycle — opened, worked, resolved, and traceable afterward, the same discipline a real engineering team runs on.
The system monitors its own health as closely as it monitors the market — a stalled or silently failing process is visible immediately, not discovered days later.
Data is encrypted at rest, and every external connection runs over TLS with certificates that rotate automatically well before they expire. Internal traffic never leaves the machine.
Prices update as each exchange closes in its own timezone — the Australian close is captured while London is still trading, and London's while New York runs. Every position's trigger is re-evaluated that same night, against every market's most recent close.
The system was designed to keep data secure — local dedicated hardware, not cloud infrastructure. Each function's frontier LLM, and the provider behind it, can be swapped independently; nothing here depends on one vendor.
Coverage doesn't wait for someone to ask for it. Each layer runs on its own cadence, and a company only enters the slow, adversarial part of the cycle once the fast, mechanical part has already done its job.
Every company in the universe is re-evaluated and re-ranked against current filing and market data — every night, not on a slower cycle.
When the shortlist's membership actually changes, the ranked list is reviewed and the candidates worth acting on are handed to the recommendation function. Unchanged nights don't manufacture a review.
Every open position carries a trigger price. Each market's close is captured within minutes of that close, and every position is re-evaluated against it the same night. We don't trade, so we don't watch ticks.
A full four-function research cycle runs on demand for any company, on the same fixed sequence and standards every time.
Every closed decision updates the benchmarks the next one is measured against — the process gets stricter over time, not just busier.
Research establishes the base, straight from the filings — there's nothing before it to read. Everything after it works differently: Valuation prices what Research found, Challenge is tasked with finding what's wrong in both, and Recommendation reads all three and is free to disagree, as long as it says why. Agreement isn't assumed anywhere in that chain; it has to hold up.
Builds the case for what the business is and what it's worth owning, from the filings up — with no visibility into the valuation or challenge functions' output.
Independently prices the business under bear, base, and bull assumptions before seeing any challenge to the research it's built on.
Given the research and valuation together for the first time, and tasked with finding what's wrong with them — not confirming what's right.
Reads all three outputs and forms its own view, including where it disagrees — nothing here is an average of the others.
The point where separate conclusions get folded into one is the single highest-risk step in any automated system — it's where an error is most likely to get laundered into something that looks like consensus. This architecture is built specifically to avoid needing that step.
A function can read what came before, but a claim only survives by holding up against the same source material — not because an earlier stage already accepted it.
Where two functions reach different conclusions, both are kept and shown — not blended into a single smoothed-over number.
A wrong figure introduced at one stage is checked again, independently, at the next — rather than carried forward and trusted because an earlier stage already used it.
This is the same principle that governs data sourcing and error correction elsewhere on this page — independence isn't a feature of one part of the system, it's the design constraint the whole thing is built around.
A recommendation is only as good as the system that produced it. So the system is held to the same standard as the research itself — every number traceable, every process auditable, and nothing accepted from a single source without a way to check it.
The rigor a vetted investor would expect from operational due diligence on any real research desk applies here by default, not by request. The data pipeline, the correction process, and the review architecture are all built to be examined — not just described.