I built a causal-inference engine that decides when to act, not what to trade

"My worst trades were almost never the wrong direction. They were the right idea, acted on too early, on conviction I hadn't actually earned yet."**

That sentence is the whole reason this project exists. I kept noticing that the mistake wasn't what I thought. It was when I moved. I'd see something real, get impatient, and act before the evidence had actually formed. By the time the thesis was true, I'd already been stopped out of it.

So I stopped trying to build a better answer to "what should I do?" and started building around a different question:

Has the evidence converged enough to act at all yet?

When, not what
Almost every trading model I've seen, and most of the ones I tried to build, emits a what: buy, sell, this target, that signal. The implicit assumption is that the hard part is knowing the direction, and timing is just execution.

I think that's backwards. In a noisy, reflexive system like a market, the direction is often guessable. The genuinely hard, edge-bearing question is timing: is this the moment where acting is justified, or is the honest move to wait?

So Causalea's core output isn't a price target. It's a timing judgment. It runs an online causal graph over live signals and tracks how confident each causal edge is over time. It only flags a state it calls RIPE, "okay, acting is justified now". When three things hold at once:

1. There's a clear decision on the table.
2. It survives projection over the near future (roughly the next 24h).
3. It isn't sitting in a catastrophic / tail-risk zone.

If those don't all hold, it says wait. That signal, "wait", is treated as a real first-class answer, not a failure to produce a signal.

Why I didn't just use DoWhy / CausalML
Fair question, and I looked hard at the existing tooling first. The mature causal-inference libraries are genuinely excellent — but they're built for a setting that's the opposite of mine. They assume a static, offline dataset: you hand them a frozen table, they estimate an effect, you're done. They assume the world holds still while you analyze it.

Markets don't hold still. I needed three things that framing doesn't give you:

1. Continuous, online updating. Beliefs have to revise tick by tick on a live stream, not recompute a batch estimate on a snapshot.

2. Reasoning about timing, not just effect size. "When does confidence ripen?" is a question about how belief converges over time — it sits outside the standard "estimate this coefficient" frame.

3. Honesty about non-stationarity. Relationships decay and regimes shift. The engine has to be able to say "I don't trust this edge anymore" and downgrade it, instead of treating a learned effect as permanent truth.

That last one matters most to me. An edge in this engine is a decaying, falsifiable claim, not a fact. If reality stops backing it up, it loses weight.

(If there's a streaming / online causal library I should've used instead, I genuinely want the pointer — tell me in the comments.)

What I'm honestly unsure about
I'd rather front-load the objections than pretend they don't exist:

1. "Causal inference on markets is overclaiming — it's mostly noise and reflexivity." Probably the strongest critique. My partial answer is that the engine treats edges as decaying and falsifiable rather than fixed, so an unstable "edge" should erode on its own. But I'd love to hear where that reasoning breaks.

2. "Isn't 'when, not what' just confidence-gating / position-sizing with extra steps?" Maybe. I think the causal-timing framing is doing something different, but I hold that loosely.

The track record is thin. The live engine has only been running a short while. What I have is a forming record, not a proven one — and I'm not going to dress it up as more than that.

This is educational, not financial advice. I'm not here to sell you a money machine — I'm here to share an approach and have smart people poke holes in it.

The stack, briefly
TypeScript top to bottom. Express + PostgreSQL on the back end, a custom causal engine doing the actual reasoning, and a React/Vite front end. One language everywhere, a boring-reliable server and database, and the one genuinely novel piece — the engine — built from scratch because nothing off-the-shelf reasoned about live, decaying causality the way I needed.

Where it is
There's a free tier that shows the actual loop, the causal graph, the decisions, and the readiness gauge. If you want to see the thing reason rather than take my word for it: https://causalea-live.replit.app

But mostly, I'm writing this to find the people who'll tell me where I'm wrong. If the "noise, not cause" objection is fatal, I'd rather hear it now. What would you stress-test first?