What is the problem your project solves?

Developers got the IDE. Trading agents got nothing.

When humans write code, they get an IDE: an environment that watches over the work — syntax checks, type systems, version control, a debugger, an undo button. When coding agents arrived, they got harnesses like Claude Code and T3 Code: environments built so an autonomous process can do real work safely.

Now look at trading agents. Every "AI trading bot" today is one of two things:

1. A script with an API key. The model is one hallucinated decimal away from liquidation, and nothing structural stops it. No guardrails, no environment — just raw exchange access and hope.
2. A copilot that can't act. It writes market commentary and a human clicks the button. That's not an agent. That's a newsletter.

There is no ITE — no Integrated Trading Environment. No equivalent of the IDE for agents that trade: a place that gives an autonomous agent real market access and wraps every action in deterministic checks, protection, budgets, and a kill switch. In 2026, that tooling simply does not exist. We checked. We needed it. So we built it.

What this unlocks right now

With a real ITE, one person can hand an agent a strategy, a market, and a hard loss budget — and walk away. The agent trades within its mandate, sleeps until the market actually moves, and physically cannot exceed what it was given. Not "probably won't." Cannot. That's the difference between a demo and something you leave running overnight.

What the future holds

Every domain where agents touch real value — trading, payments, treasury, procurement — needs this same shape: intent from the model, limits from the environment. IDEs made software engineering an industry. ITEs are how autonomous trading stops being a party trick and becomes infrastructure. Somebody will build the environment layer every trading agent runs inside. We started today.

How you are solving it?

T3 Trade: an ITE — the IDE, rebuilt for trading agents

T3 Trade is an Integrated Trading Environment: T3 Code (the open-source agent harness from Ping Labs) as the foundation, plus a GUI layer and an execution core that let an autonomous Claude agent trade live perpetual futures on Hyperliquid — inside an environment that enforces the rules, the way an IDE enforces a type system.

What the agent actually does

You give it a mission: one market, a written strategy, a hard max-loss budget, an expiry. Then:

1. It reads the market — price structure, ATR across timeframes, funding, fees — and decides if there's a trade at all. In our live runs it declined entries where round-trip costs ate the edge: "Stand down — no position opened."
2. It plans in writing — entry, stop, target, trailing rule — published as a versioned plan you can read in the GUI.
3. It acts through typed tools — preview, submit, cancel. No shell. No raw API key. Every order passes a 17-item deterministic checklist before anything is signed: mandate, leverage, notional, exchange minimums, budget reservation, mandatory stop.
4. It sleeps — it arms watches (price crosses X, PnL reaches Y) and suspends. The environment wakes it only when the market does something, and hands it a fresh snapshot of position, orders, and budget.
5. It manages the trade — moves stops to breakeven, trails, banks the target, or gets stopped out. Every position must have an exchange-native reduce-only stop confirmed against the canonical size read back from Hyperliquid, or the environment intervenes.

What the environment guarantees — whatever the agent decides

• The budget is physical. Full risk (planned loss + fees + slippage) is reserved before signing and released only on terminal state. The agent can't spend budget twice, or argue past a limit.
• Retries can't double a position. Deterministic order ids (SHA-256 of mission ‖ sequence ‖ action) + an idempotency key: a retried submit returns the existing record.
• The exchange is the truth. Positions, orders, and fills are always reconciled from Hyperliquid. The database records what the agent did; the exchange decides what is true.
• The kill switch skips the model. Pause, cancel entries, reduce 25–100%, close, revoke — seven controls in the GUI that run deterministically with the agent process stopped.

The GUI layer

An IDE isn't just a compiler — it's the window on the work. The T3 Trade workspace shows the agent's plan, the live position chart with entry/stop/target bands, the armed watches, risk-per-position, and one-click human controls. You supervise a trader, not a terminal.

Scope and prior work — disclosed

The foundation is T3 Code, an existing open-source agent harness from Ping Labs — we forked it and kept it close to upstream (every divergence is tracked in docs/upstream/PATCH_LEDGER.md). Everything that makes it an ITE was built during this hackathon:

The commit history on the public repo shows the split directly. Not previously submitted anywhere. Hyperliquid testnet only — live signing arms solely via a signer key; without it the environment runs read-only.

How Did You Use Claude?

Claude is the trader. The ITE is built around it.

1. Claude runs the mission

Every mission is a Claude agent thread bound to one market. Claude reads the snapshot the environment hands it — account, position, resting orders, remaining budget — and does what a trader does: sizes an entry, places a stop, trails a winner, or refuses the trade because the math doesn't clear the fees. In our live testnet runs, Claude declined chop, priced round-trip costs into its targets, and wrote its reasoning into versioned plans you can read in the GUI.

2. The ITE thesis, in one line

Claude gets full authority over intent, and zero authority over limits. It acts only through typed tools — trading_preview_order, trading_submit_order, watch registration, trading_control_* — and every action passes a 17-item deterministic checklist before a signature exists. Claude proposes; the environment disposes. That separation is what makes handing a frontier model a live exchange account something you can defend, not just demo.

3. Event-driven, so autonomy is affordable

Claude isn't polled in a loop. It arms watches (price levels, PnL thresholds, candle closes) and suspends; the environment resumes it only when a watch fires. A mission can run for days with the model invoked only when the market moves — which is what makes an always-on Claude trader economically real.

4. Claude Code built the ITE itself

The entire environment was built inside T3 Code driving Claude Code, as a sequence of phased agent handoffs (execution-plan.md, PROMPT-04/05/06 in docs/architecture/trading-execution.md). Each phase documents the service surfaces, semantics, and caveats it hands to the next agent — the docs read as contracts between Claude instances. Claude built the environment; Claude trades inside it.

5. Why this matters beyond perps

The hard problem was never getting Claude to reason about a chart — it does that today. The hard problem was the environment where an autonomous Claude can hold real capital and be structurally incapable of exceeding its mandate. Typed tools, deterministic previews, reserved budgets, mandatory protection, out-of-band kill switches: that's the ITE pattern, and it generalizes to every domain where agents will touch money. Perps are the proof. The environment is the product.

What is the deployed URL for this project?

https://t3trade.pages.dev