The time-integrity layer
Prove your AI didn't see the future.
Strathora locks backtests and AI agents to what was knowable, and proves it.
Data quality first. Every row timestamped, every gap flagged, unknowns labeled, never guessed.
Book a demoBuilt for
Teams that have to prove what their AI knew.
If someone else has to trust your results, Strathora turns “trust me” into a receipt they can check.
The problem
Your customers' first question is “does your AI cheat?” LLM agents can see the future through corrected data, news tools that return newer articles, or the model's own memory.
Why it matters
Funds won't trust an agent they can't verify. Every unanswered doubt slows a deal or kills it.
What you get
- Time-locked data, tools and model calls via AsOf
- A receipt for every decision your agent makes
- Model-memory labels you can show customers honestly
The impact
Typical ranges · estimates, not guarantees
Engineering time
~$30–60K one-time
- Today: 2–4 engineer-months to build time-locking + logging
- With Strathora: An afternoon to install
Diligence effort
~40–100 hrs / yr
- Today: 10–30 hrs per customer “does it cheat?” review
- With Strathora: Share receipts + report
Deal speed
Fewer stalled deals
- Today: Deals stall on trust questions
- With Strathora: Evidence on request
Ongoing upkeep
~0.25 FTE / yr
- Today: Maintaining audit trails as models change
- With Strathora: Built in
Workforce freed
≈ 0.0 FTE back to building product
Assumes $90–180K/yr per engineer or quant. Your numbers will differ; a sprint measures them.
Run your own numbersThe problem
A strategy looks great in the backtest and bleeds live. Finding out why takes weeks of senior quant time.
Why it matters
Edges decay faster than ever. Every week chasing a fake edge is capital and research time you don't get back.
What you get
- Look-ahead checks across data, tools and model memory
- Data-quality flags: backfills, restatements, survivorship
- A breakdown of the live vs backtest gap: costs, slippage, timing, decay
The impact
Typical ranges · estimates, not guarantees
Investigation time
~$20–60K / yr
- Today: 1–3 weeks of quant time per “what happened?”
- With Strathora: A breakdown in hours
Capital at risk
$20–100K loss avoided · per caught edge, e.g. on $2M
- Today: Capital deployed into edges that were never real
- With Strathora: Caught before allocation
Research cycles
~20–40% of review time
- Today: Hours per idea checking look-ahead by hand
- With Strathora: Automatic on every run
Data vendor risk
Bad datasets caught early
- Today: Backfilled data found too late
- With Strathora: Flagged on import
Workforce freed
≈ 0.0–0 FTE back to research
Assumes $90–180K/yr per engineer or quant. Your numbers will differ; a sprint measures them.
Run your own numbersThe problem
Allocators ask how they can know your track record is real, and “trust me” isn't an answer.
Why it matters
Due diligence is slow and skeptical. Independent evidence can make the difference between a meeting and an allocation.
What you get
- A sealed record of every decision as it happened
- A Verumark report with honest Verified / Observed / Unknown labels
- Evidence that can't be rebuilt after the fact
The impact
Typical ranges · estimates, not guarantees
Diligence prep
~60–120 hrs / yr
- Today: Weeks assembling evidence per allocator
- With Strathora: Export a report
Track record trust
Stronger diligence answers
- Today: “Trust me”
- With Strathora: Sealed, timestamped record
Follow-up rounds
~30–50% fewer back-and-forths
- Today: Rounds of email per allocator
- With Strathora: Point to the evidence
Cost of time
~$10–25K / yr
- Today: Founder hours away from investing
- With Strathora: Time back to the portfolio
Workforce freed
≈ 0–0 founder weeks back per year
Assumes $90–180K/yr per engineer or quant. Your numbers will differ; a sprint measures them.
Run your own numbersThe problem
You're judging a strategy you didn't build, from results you can't fully see behind: repainting, look-ahead, cherry-picked runs.
Why it matters
Funding the wrong strategy costs capital and credibility. Relying on the builder's word is the risk you're paid to remove.
What you get
- Import checks for repainting, modeling mode and intrabar ambiguity
- Timing checks on every input
- A clear report: what's proven, what isn't
The impact
Typical ranges · estimates, not guarantees
Review time
~$15–50K / yr
- Today: Hours to days per outside strategy
- With Strathora: An evidence report on import
Bad funding
$5–20K per caught strategy, e.g. on $100K
- Today: Capital given to repainted or look-ahead strategies
- With Strathora: Flagged before funding
Consistency
Repeatable reviews
- Today: Depends on which reviewer checks it
- With Strathora: Same checks every time
Documentation
~2–4 hrs per review
- Today: Manual write-ups
- With Strathora: Report with labels
Workforce freed
≈ 0.0 FTE back to sourcing strategies
Assumes $90–180K/yr per engineer or quant. Your numbers will differ; a sprint measures them.
Run your own numbersVisuals are illustrative.
Plugs into
Python
Claude
Jupyter
pandasPythonClaudeJupyterpandasSee it work
Set the clock. The future stays locked.
Pick a moment in time. AsOf serves only what was knowable then, blocks the rest, and writes a receipt.
Watch it run
A time-locked session, start to finish.
- 01Set the clock
- 02Future blocked
- 03Receipt
- 04Clock moves past earnings
- 05Tamper, caught
Demo run on synthetic data. Nothing here is investment advice.
Try to tamper
Change one value. The chain notices.
Change a value. The hash chain will notice.
- recorded
- …
- recomputed
- …
Each hash covers the event and the one before it, recomputed live with SHA-256 in your browser. Only the edited event fails, as in asof verify.
Proof in three steps.
Connect
Wrap your data, tools and model calls with AsOf. Lines from the demo's own source, with the privacy and ledger options left out.
Run
The clock only moves forward and the future stays locked. This is the receipt the demo printed.
Prove
Verify the ledger, then build a Verumark report from the stored events.
Plug it in
One connector. Your stack stays the same.
- Python SDK
- MCP server for agents
- REST API
from asof import Session
with Session(as_of="2023-01-20T14:00Z") as s:
rows = s.query("prices", ticker="NVDA") # only what was knowable at T
s.receipt() # sealed, hash-chained proofThe clock only moves forward. An agent can't rewind it to peek.
Your data stays yours
Runs in your environment
Deploy next to your data. Nothing leaves unless you send it.
Hashes-only mode
Prove what the agent saw without us storing the content.
Never used for training
Your data and your strategies are never used to train anything.
What you get back
Every run ends with a receipt.
Every run produces one of these. Hand it to your PM, your risk team or an auditor.
- clock_T
- 2023-01-20 14:00 UTC
- served
- 7 rows(available_at ≤ T)
- blocked
- 3 items(published after T)
- model_memory
- OBSERVED
- data_checks
- 2 warnings: backfilled rows, survivorship
- receipt_hash
- 9f3a…c21e
Honest labels. Not green checkmarks.
Every check says what was proven, what was only observed, and what couldn't be checked. A closed model's memory is never labeled Verified.
We don't build or run your strategy. We control what it can see and record what it did.
Data
All 412 price rows timestamped before T
Tools
news_search returned 1 article from after T
Model memory
Closed model; probed, cannot be proven clean
Execution
Fill prices not synced in hashes-only mode
Example report rows, illustrative.
Ask questions inside Claude. The clock stays locked.
ClaudeAs of Jan 20, 2023, what's the latest news on NVDA?
ticker: "NVDA" · as_of: 2023-01-20T23:59Z
2 articles available as of your clock. 1 later article was blocked. Receipt #15043 written.
Illustrative. The AsOf MCP server owns the clock; the model can't move it.
Temporal Ledger
Three clocks on every event, hash-chained and append-only.
Proving Ground
Build agents where every run is time-locked and checked.
Governance
Approvals and limits for agents moving toward live capital. Early access.
Read the report, section by section.
This is the sample PDF, laid out on the page: honest labels, no single score, and a plain list of what was not checked. Synthetic data, not a customer result.
- As-of
- 2023-02-01 23:00Z
- Run
- r_b8851f069e8d
- Imported
- 1 decision
- Engine
- AsOf 0.1.0
Nothing was flagged in the records that could be checked. No expected-versus-live comparison was possible (see Unknowns).
Coverage by dimension
No single score1 of 1: decisions whose recorded inputs all carry an availability time (and that record at least one input).
1 of 1: tool calls with a recorded return time.
0 of 1: models in the log that have at least one probe result; labelled observed susceptibility at best.
0 of 0: orders linked to a fill by the order id the agent recorded.
Not measured: training-data exposure (usually unknown); model identity and version beyond the name the log states; reproducibility by rerun (this report is a replay).
Data timing
VerifiedNone of the 5 timestamped inputs was available after its decision.
Checked 5 of 5. Only inputs the agent's log recorded are checked. An input the log omits cannot be tested, and a timestamp the log states is taken as stated (the ledger proves it is unchanged since capture, not that it is right).
Tool integrity
VerifiedNone of the 1 timestamped tool results returned after its decision, and no later date was found in any result.
Checked 1 of 1. Structured date fields are read as stated. Dates inside free text are matched by pattern and may belong to something other than the fact in question.
Model memory
UnknownNo probe results were supplied, so whether the model already knew what happened after its decision dates is unknown.
Checked 0 of 1. A model's training-data exposure is usually unknowable from outside. Probes sample it; they cannot prove its absence.
Execution
UnknownThis session recorded no orders, so no decision could be linked to an execution.
Checked 0 of 0. Orders and fills are what the agent's own code recorded; AsOf cannot see an exchange.
Ledger chain integrity
Verified25 events, hash chain intact, tail anchor ok.
Log sha256 327de3a20c88ae33…
Post-trade attribution
UnknownNo orders were recorded, so no result is linked to a decision.
Data quality of sources
| Source | Records | Event time | Availability | Flags |
|---|---|---|---|---|
| synthetic_prices | 6 | 100% | 100% | none |
What the time lock withheld
Served 5 (5 with declared timing, 0 unknown)
Timestamps on what was served: 100% event time · 100% availability · newest record 23 h before T
Served 3 (3 with declared timing, 0 unknown)
Memory label: unknown
Declared cutoff: unknown · contamination score: none registered
The model's training cutoff is unknown: it may remember events after T.
Recorded at the session clock; this is the point Verumark checks each input against.
Unknowns
Unknown- Model memory: no probe results were supplied, so whether the model already knew what happened after its decision dates is unknown.
- Post-trade attribution: no orders were recorded, so no result is linked to a decision.
- Expected versus live: no comparison was possible.
- Training-data exposure of closed models is usually unknowable from outside.
What this report does not prove
No result here means a strategy is profitable or safe. It shows which inputs were checked against the decision time, and which could not be. This report is a replay of the stored events, not a rerun.
- Report
- abfc451bc51b77cc
- Sealed
- 0364cac2c3226ff1
- Result
- verified 50% · observed 0% · unknown 50%
Synthetic demo. Not investment advice.
I started building trading bots. I ended up building proof.
I didn’t set out to build a verification company. I set out to build trading bots.
I’m 21. I’ve spent the last few years building things: Neuraify, an AI study tool that syncs with Canvas, Blackboard and Google Classroom, and Rovaire, a studio building chatbots and workflow automation for businesses. I left Georgia State to build full-time.
Shipping those taught me how to move fast. It also taught me something I didn’t appreciate at the time: the hardest part isn’t building the product. It’s knowing whether the thing you built actually works.
When I started what became Strathora, the plan was simple: quant-level AI agents for trading firms. I called it Stratton Labs. I built a backtesting engine, a slick interface, a list of features. Then I started talking to people who actually do this for a living.
01
The conversations that changed everything
I talked to prop traders, quant researchers, fund advisors and managers. Three conversations stuck.
“Stop. Building a tool to find edges is the wrong problem. The hard part isn’t finding a strategy that looks good. It’s knowing whether you can trust it.”
“When a strategy blows up, nobody can prove why. There’s no record of what the system saw, when it saw it, or what it decided.”
“The thing that haunts me is look-ahead bias: results that look incredible because the data quietly leaked the future into the past.”
I started to notice a pattern. Everyone had their own way of dealing with it. None of them could prove it to anyone else.
02
The problem underneath all of it
Experienced people avoid look-ahead through knowledge and discipline. AI agents don’t have that knowledge. They can use corrected data, a news tool that returns an article from after the date they’re supposed to be standing on, or a language model that already “knows” how the story ended. And neither does everyone trying to review a strategy they didn’t build.
The real question isn’t “is this strategy good?” It’s “can you prove what your system knew, and when it knew it?”
03
What I’m building
Strathora is the time-integrity layer for financial AI. It does three things.
- Locks the clock. Data, tools and model calls only see what was knowable at the time.
- Records everything. An append-only, hash-chained ledger of every decision and what was blocked.
- Hands you proof. A report with honest labels (Verified, Observed, Unknown) instead of green checkmarks.
What we don’t do
- Build the trading agent
- Give investment advice
- Certify profits
We make AI results provable.
04
Where things are
Strathora is early, and I’d rather be honest about that than impressive. The next proof has to come from real strategies, not from me.
- Working, heavily tested build on synthetic dataDone
- Booking first evaluation sprints with small funds and AI trading teamsOpen
- Proof on real strategiesNot yet
If you build or review AI for trading, I’d love to talk. Prove your AI didn’t see the future.
Lucas Costache
Founder & CEO, Strathora
Start free. Prove it. Scale when ready.
Evaluation Sprint
$3,000 · 30 days
We run your strategy or agent through the full check, lock, seal and prove flow. Credited toward the platform.
Book a sprintQuestions quants actually ask.
Straight answers, including what we can't do. If it's not here, ask us directly.
- Local-first
- Hashes-only mode
- Honest labels
Security & data
local-firsthashes_onlysync: opt-inHow it works
pip install asofMCPCLICSV · Parquet · JSONLLimits
Getting started
Demo data on this site is synthetic. Nothing here is investment advice.
Put proof behind every decision.
See how Strathora can make your firm's AI results verifiable.
Book a demoOr reach the founder directly: LinkedIn