TradingCodex
Turn Codex into an evolving multi-agent investment research team that assembles the right analysts per question and leaves reusable, auditable research memory.
Per-dimension scores and reasoning
README states explicit guardrails (research never becomes broker action, paper-first, credentials never in prompts/workspace), and the test code requires project hooks to be persistently trusted while rejecting --dangerously-bypass-hook-trust; CI uses minimal permissions (contents: read, persist-credentials: false). Deducted because approval gates, the permission model, and credential-handling implementations plus docs/safety-policy-and-execution.md are not in evidence — safety claims are largely asserted; rollback is only referenced via an unseen installation.md; attribution is thin (anonymous 'TradingCodex Authors', NOTICE not shown).
README, pyproject (tcx entry point, Django 5.2, dynamic version), CI, and tests are mutually consistent; dependencies carry version bounds with lock files and uvx refresh mentioned; test failure messages are specific and actionable (missing features, untrusted hooks with remediation steps). Deducted because visible code only covers install-contract tests; runtime failure handling cannot be confirmed from evidence.
Audience (investment researchers) and scenarios (research, review, postmortems) are clear; execution agents are explicitly excluded and skill boundaries defined; macOS/Linux/Windows supported with minimum and reference Codex versions. Deducted because precise skill trigger rules live only on an external docs site, unverifiable within the evidence.
Information architecture is excellent: layered workspace (research/reports/wikis/brains) and a clear docs index; full Apache-2.0 with NOTICE and trademark references; install notes cover three platforms including restart and hook-trust steps. Deducted for: no CHANGELOG (dynamic version only), known limitations not documented as such, anonymous maintainership, and examples/FAQ relying on external links.
Outputs are readable, versionable files and persistent memory layers reusable across sessions, distinct from one-off chat; the dynamic agent team plus static memory adds marginal value over bare Codex. Deducted because recommending gpt-5.6-sol high/xhigh reasoning implies significant multi-agent token cost, unquantified in evidence.
README claims cross-check against pyproject, CI, and tests (tcx commands, hook event set, feature-flag checks); facts and inference are reasonably separated. Deducted because core safety and execution claims point to documentation files outside the evidence set, leaving them assertion-level for this static review.
- Static review with low confidence: key implementations of permissions, approvals, and credential handling plus the safety document are outside the evidence; safety claims are README assertions only — review docs/safety-policy-and-execution.md and hook code yourself before use.
- Installation requires trusting all project hooks, granting workspace code significant control over Codex; inspect the generated .codex/hooks. before trusting.
- Publisher is unverified and authors are anonymous; update and vulnerability-response paths are unclear.
- Recommended multi-agent research with high/xhigh reasoning incurs substantial model cost; budget accordingly.
- The product targets investment research, not advice, and carries no broker-execution authority; live trading requires your own additional approval and audit setup.
What does this agent do, and when should you use it?
TradingCodex is a multi-agent investment research system that runs natively inside the Codex CLI. A Head Manager reads each question and dynamically coordinates up to nine specialist agents — fundamental, technical, news, macro, instrument, valuation, portfolio, risk, and judgment review — choosing the smallest useful team and parallelizing independent work. It is explicitly research-first, local-first, and paper-first: a research answer never becomes a broker action on its own. Outputs persist as inspectable, versionable static layers (Research Memory, Knowledge Wiki, Investment Brain, Decision Memory, Strategy) under local directories such as trading/ and wikis/. The product ships as a PyPI package (tradingcodex), attaches to a user workspace via uvx and the tcx command, and includes a read-only viewer at http://127.0.0.1:48267/ by default. It is built on Python 3.11-3.14 and Django 5.2 under an Apache-2.0 open-core license, and suits users who want natural-language-driven, structured investment research with Codex as the host environment.
You ask a question in ordinary language inside your attached workspace; the TradingCodex Codex hooks start the Head Manager, which dispatches the smallest useful wave of specialists, runs independent work in parallel, and collects accepted evidence and artifacts. The workflow is a loop — question → Head Manager → specialist wave → evidence/artifacts → follow up / add a role / request review / synthesize / stop — not a preset DAG. Six skills are invoked by pasting prompts: $tcx-plan (frame outcome, scope, stop conditions), $tcx-workflow (run dynamic research), $tcx-memory (replay prior judgment), $tcx-wiki (curate company/industry background separate from live evidence), $tcx-brain (define inquiry frameworks with falsifiers and limits), and $tcx-strategy (define entry, sizing, and invalidation rules). Results are written to research/, reports/, forecasts/, and decisions/ directories, and the read-only viewer shows Episodes, Library, Wiki, and System posture. Broker execution is separated into its own checkpoints: provider connection, ticket drafting, checks, approval, and final action.
- An individual investor analyzing a stock like MSFT under a 'medium-term quality compounder' mandate, explicitly requesting contrary evidence
- A researcher replaying a prior thesis against what was known at the time to test whether lessons still hold ($tcx-memory)
- An analysis team storing stable semiconductor value-chain facts in the Wiki, kept distinct from live evidence
- A cautious user defining reusable entry, sizing, and invalidation rules as a reviewable Strategy that shapes later research without granting execution authority
- A developer building a paper-trading research pipeline locally without wiring up a live broker
What are this agent's strengths and limitations?
- Dynamic staffing: the Head Manager picks agents based on the next useful question — narrow questions stay direct, high-consequence recommendations expand to independent portfolio, risk, and judgment review
- All research output lands in inspectable, versionable local files (research/, reports/, forecasts/, decisions/) rather than being hidden in chat
- Hard execution guardrail: research, Wiki, Brain, and Strategy confer no broker authority; live trading requires separate installation, policy approval, explicit confirmation, sync, and audit gates
- Clean knowledge separation: a Wiki never becomes proof, a Brain never picks agents, and improvement records never silently rewrite prompts, skills, policy, or execution gates
- Tightly coupled to the Codex CLI ecosystem — an authenticated codex CLI is required and the system cannot run without it
- Full workflows recommend gpt-5.6-sol with high/xhigh reasoning, which may be costly
- Local-first operation means you manage the workspace, hook trust approvals, and the tcx service process yourself
- Live trading is not turnkey: it needs a separate provider installation, policy approval, explicit confirmation, sync, and audit gates, and no concrete broker list is documented
How do you install or deploy this agent?
Prerequisites: Git, uvx, and an installed, authenticated codex CLI. Prepare an empty workspace directory (do not clone this source repository into it). macOS/Linux: cd /path/to/an/empty-workspace && uvx --refresh --from tradingcodex tcx attach . && ./tcx doctor && ./tcx service ensure. Windows PowerShell: cd C:\path\to\an\empty-workspace, then uvx --refresh --from tradingcodex tcx attach ., then run .\tcx.cmd doctor and .\tcx.cmd service ensure. After installation, fully restart Codex, reopen and trust the workspace, and approve every TradingCodex hook when prompted.
How do you use this agent?
After restarting Codex, paste a skill prompt into a new Codex task, e.g. 'Analyze MSFT as a medium-term quality compounder. Include contrary evidence. No order.' ($tcx-workflow) or 'Create a cautious quality-compounder inquiry framework.' ($tcx-brain). Run ./tcx service status to get the read-only viewer URL (default http://127.0.0.1:48267/) and inspect Episodes, Library, and Wiki in a browser; continue, narrow, or stop the work inside Codex. For full research workflows the project recommends the gpt-5.6-sol model with high or xhigh reasoning.
How does this agent compare with similar options?
The README names no direct competitor, but compared with single-agent tools that run a fixed analysis checklist per ticker, TradingCodex varies its team per question and reuses research context across sessions through a local memory stack (Wiki, Brain, Decision Memory).