Judex

Deployed, not demoed

Most AI investment tools are demos: impressive on stage, untested where it hurts. Judex was built the other way round — for the hardest first customer, myself, with my own money on the line, in production from the first week. Every design decision was made next to the problem, not in a slide deck: the daily brief exists because I needed one; the approval flow is one tap because a second tap was one too many; the scorecard grades my verdicts, not just the system's, because both can be wrong.

Once the loop held up under real use, the platform was made multi-tenant — per-user portfolios, keys, briefs, and strict isolation — and opened to family and friends pre-launch.

The daily rhythm

Judex runs on a clock, not on a prompt. Every trading day:

1. Afternoon · after the data lands

   Prices, fundamentals, and portfolio positions refresh; the decision engines evaluate every holding and every candidate against versioned rules.

2. Minutes later

   Briefs arrive by email: what the system recommends, why, and what it deliberately did not recommend. Reading them takes two minutes.

3. Your move

   One tap opens the approval page. Agree, reject, or deselect individual items — the human always holds the pen.

4. On approval

   The agent account executes; fills are captured and reconciled. On the main account nothing is ever placed automatically — approvals are recorded, and a reconciler verifies what you did by hand.

5. Always

   Every recommendation enters a ledger with your verdict, and a monthly scorecard grades what the advice was worth — and what your decisions were worth.

Two engines, one discipline

In both engines the division of labour is strict: rules decide; AI only explains. The language model writes the reasons a human can read — it never picks the trade. And missing data is never guessed: a name with an unknown fundamental is excluded, not assumed healthy.

Where the agents work — and where they may not

Agentic AI earns its place in Judex at two points, each inside a fence:

That is the pattern throughout: agents do real analytical work — multi-angle, contextual, language-native — but always inside boundaries drawn in code, never on trust.

Trust is engineered, not promised

Advice you cannot audit is opinion. Judex treats auditability as a feature with an architecture:

• —

  Every recommendation carries an id and a rules-version hash. When a rule changes, past decisions keep the rulebook they were made under, and are graded on their own terms. History is never rewritten.

• —

  The method is published to its users. A written method statement explains every gate and threshold in plain language, and a dated case file walks one real recommendation end to end — recorded inputs, scores, and the exact sentence the system gave as its reason.

• —

  Every decision is traceable in the portal. Click any recommendation and see the data it used, the rules in force, your verdict, the fill, and what the call has been worth since — including the honest what-if for the ones you declined.

• —

  Isolation is tested, not assumed. A tenant-isolation suite of 24 checks runs against the live system after every relevant deployment — each past class of leak became a permanent guardrail.

The loop: field evidence changes the rules

Because every evaluation of every stock is logged, the system's flaws have nowhere to hide. A recent example: the trend rule required a stock to stay above its 50-day average every day — which disqualified names in the middle of exactly the dip the strategy exists to buy. The rule was closing the window it was built to open.

The revision tests the structure of the trend instead — the moving averages stacked in order, which an ordinary pullback cannot break — and it shipped the way every rule change ships: versioned, dated, documented in the method statement, with prior recommendations untouched. Log everything, find the flaw, revise the rule, keep the history. That loop is the product.