Letting software trade your brokerage account is a real trust decision. This page describes exactly how it is built, what leaves your machine, and what our servers receive - including the parts that are limitations rather than features.
trelic is a desktop application, not a hosted service. The agent loop - reading your positions, pulling quotes and option chains, deciding what to propose - runs on your machine. It talks directly to your broker and directly to Anthropic using your credentials.
That has a real consequence worth stating plainly: if your computer is off, the agent isn't running. A cloud service would keep working. We chose local-first because it means we never need your broker login, and that tradeoff cuts both ways.
Two things, and nothing else:
Your license key and a device identifier, so a subscription works on your machines and not on twenty others. We store a hash of the key, never the key itself - which is why the dashboard shows only a prefix.
If you use the mobile companion, ciphertext passes between your desktop and phone. We can see that a channel is active. We cannot see what's in it.
Your positions, orders, P&L, strategies, and reasoning stay on your machine. There is no analytics pipeline collecting them, because there is no pipeline at all.
When you pair your phone, the desktop generates a 32-byte secret and shows it once. You type it into the phone. Both sides then derive two separate values from it:
channelId = HKDF-SHA256(secret, info="trelic-remote-channel") (16 bytes)
key = HKDF-SHA256(secret, info="trelic-remote-key") (32 bytes, AES-256-GCM)
The relay is given the channel id, so it knows which two devices to connect, and the encrypted envelope to pass along. It never receives the secret or the key. The two values come from HKDF (RFC 5869) under different info labels - the construction built for deriving independent keys from one secret - so holding the channel id reveals nothing about the key.
Encryption is AES-256-GCM, which is authenticated - a tampered message fails to decrypt rather than quietly producing different plaintext.
You don't have to take our word for this. The full implementation is published at github.com/FITCH-B/trelic-companion-crypto - both the desktop side and the phone side, so you can read it, check that the two halves derive the same key, and confirm that nothing is sent in the clear. You can also compare it against the code your phone actually loads at /app/crypto.js.
To be precise about the limits: the relay does learn metadata - that a channel exists, roughly when messages flow, and how large they are. It does not learn contents. And push notifications are deliberately content-free: the phone is told that something needs attention, never what.
This is the part we'd most want a sceptical reader to notice.
You write your strategy in plain English, and the model is good at following it. But an instruction in a prompt is a preference, not a guarantee. A model can misread a situation, decide the thesis still holds, or simply not act on the cycle where acting mattered.
We learned this from real trade data rather than theory. Across 152 closed positions on one account, 11 trades - roughly 7% - accounted for about 47% of total losses. The strategy text already said to cut losers. That wasn't enough, because nothing enforced it.
So the controls that must happen are not requests to the model. They run in the application:
The model proposes. The application decides whether that proposal is allowed. Those are deliberately two different pieces of code.
trelic will not make you money, and we won't pretend to know whether it will. It is a tool that researches, proposes, and - with your permission - places trades, with controls designed to limit what a bad run costs you. Trading options carries substantial risk of loss. Paper mode exists so you can run the entire pipeline against live prices with fake money before risking a dollar, and we'd genuinely rather you used it first.