What is OpenAlice

OpenAlice is a local trading workspace for coding agents. It starts from one belief: a serious trading task is not a chat message or a button click. It is an abstract coding task.

A tradeable decision has inputs, intermediate artifacts, state changes, review, execution, monitoring, and post-mortem. That shape is already familiar to coding agents. They know how to inspect files, call CLIs, write reports, compare diffs, commit changes, and ask for approval before doing something irreversible.

OpenAlice gives that familiar loop a trading workspace: issue-shaped task management, tracked entities, markdown research reports, inbox delivery, market-data tools, file-backed state, and an optional beta trading layer for account operations.

The Core Bet

Instead of building another closed trading chatbot, OpenAlice turns existing coding agents into trading agents.

Claude Code, Codex, opencode, Pi, or any compatible coding agent can run inside an OpenAlice workspace and keep its native strengths: prompt cache, terminal habits, file editing, tool calling, and provider login. OpenAlice does not replace the model loop. It gives the model loop a place to work.

That place is a directory:

• Data is CLI-shaped - market data, news, fundamentals, technical analysis, account state, and trading actions are exposed as command-line tools the agent can call and compose.
• Research is file-shaped - markdown reports, watchlists, tracked entities, issue files, and inbox notes become durable artifacts instead of disappearing into chat history.
• Work is issue-shaped - an issue is a self-describing unit of work, similar to a Linear ticket. Status, priority, assignee, context, links, and comments tell both the human and the agent what matters.
• Scheduling is self-describing - add when, what, and agent to the same issue file, and the issue becomes a scheduled run. There is no separate job registry to keep in sync.
• Memory is graph-shaped - tracked entities and [[wikilinks]] let Alice maintain an Obsidian-like map of assets, topics, theses, and recurring work.
• Trading is optional and approval-gated - if you connect accounts, order intent flows through the UTA beta stack and Trading as Git.

The result is closer to Linear + Obsidian for a trading desk than to a broker bot. Alice can keep work organized, remember what matters, run recurring checks, and report back with durable artifacts. Actual broker execution sits behind a separate approval-first beta layer.

How Trading Work Is Organized

OpenAlice is not a fixed workflow. The slogan is "your one-person Wall Street" because the system is organized around the kinds of work an institutional trading desk has to do, then lets agents execute those jobs inside workspaces.

Those jobs include:

• Idea discovery - finding unusual moves, new catalysts, crowded trades, sector rotation, and market regimes worth attention.
• Trend and theme research - building context around assets, sectors, macro variables, and narratives that may matter over multiple sessions.
• Topic tracking - keeping a living memory of assets and themes through tracked entities, backlinks, watchlists, and recurring notes.
• Pre-trade research - turning a possible trade into a thesis, invalidation level, data provenance, sizing context, and risk checklist.
• In-trade timing - monitoring price action, news, liquidity, technical levels, and changing conditions while a thesis is active.
• Risk approval - separating proposed order intent from execution approval, with a durable record of what was approved or rejected.
• Post-trade adjustment - reviewing fills, portfolio state, drawdowns, thesis drift, and whether the next action is hold, trim, add, hedge, or exit.

The Workspace system is what makes those tasks agent-operable. A workspace gives an agent files, git history, markdown reports, issues, tracked entities, Inbox delivery, market-data CLIs, and optional UTA tools. Different agents can work in different workspaces, but the important trading objects stay visible: the issue that describes the job, the tracked entities it touches, the report it produces, and the approval record if it reaches execution.

This is why OpenAlice treats automation as workspace work, not as a separate bot layer. A timer does not call a magic trading endpoint. It launches an agent against a self-describing task, with the same files, tools, memory, and reporting path a human-attended session uses.

What OpenAlice Provides

Workspaces

A Workspace is the agent's operating room: a per-task directory, a git repo, and a persistent terminal session running your chosen agent CLI (claude, codex, opencode, pi, or shell). The agent can read and write ordinary files while calling OpenAlice tools through alice, alice-uta, alice-workspace, and traderhub.

Workspaces are the default surface for non-trivial AI work because they keep context durable. The research, instructions, generated files, issue updates, and terminal history stay in one place.

Issues

OpenAlice issues live as markdown files under .alice/issues/<id>.md. They are readable by humans, editable by agents, and visible in the Web UI issue board.

An issue is both a coordination object and an execution object. Its frontmatter carries human workflow fields (status, priority, assignee) and can also carry automation fields (when, what, agent). That makes urgency and scheduling part of the work item itself, instead of hidden in a separate scheduler UI.

Tracked Entities

Tracked entities are Alice's long-term memory for assets, themes, people, sectors, and open theses. They let a workspace attach new findings to [[names]] that can be searched, linked, and revisited across future work.

This is the Obsidian side of OpenAlice: a research graph that grows while the agent works, rather than a pile of isolated chat transcripts.

Inbox

The Inbox is the delivery surface. Workspace runs can push rendered markdown reports back to you, linked to the workspace, issue, and source document that produced them.

That matters because not every result should be a chat reply. A recurring scan, thesis update, earnings note, or sector monitor should arrive as a durable report you can open, reply to, and trace back to the files that produced it.

Web UI

The Web UI wraps the work surfaces: Ask Alice, Workspaces, Issues, Tracked, Inbox, market views, settings, and the beta trading pages. Daily use is intentionally closer to an operations desk than a chat app: work items, long-term memory, reports, and review surfaces all stay visible.

Research and Data

OpenAlice ships with a broad research surface:

• market data across equities, crypto, commodities, FX, and macro series
• keyless read-only crypto K-line sources out of the box
• symbol search and federated bar lookup
• company profiles, financial statements, ratios, earnings, insider activity, and movers
• technical analysis through the Quant Calculator
• RSS collection and searchable news archives

The agent can use these from a workspace without needing a separate data notebook or broker terminal.

Beta Trading Layer

OpenAlice can also connect broker accounts through a Unified Trading Account. UTA hides broker-specific details behind one account abstraction and owns the account's trading history, snapshots, and execution path.

Trading as Git is the required workflow once you use UTA. Alice can submit order intent, but execution is separated from submission: staged operations are committed with a message, reviewed, and pushed only after human approval. That mirrors how a real trading desk separates traders from risk approval, and it leaves a record for later analysis.

This separation also matters architecturally. It lets Alice and UTA run in different trust zones: Alice can research and propose from the main app, while a trusted UTA device holds exchange keys and performs the final approval/execution step. The co-located UTA service already follows this split, and a standalone UTA deployment tool is planned.

This layer is still unstable beta infrastructure. Use paper or demo accounts first. If you hit UTA errors, broker connection failures, or confusing execution behavior, bring the error to the community or open a GitHub issue so we can reproduce it.

Why Local and File-backed

OpenAlice runs on your machine. Trading involves private keys, account state, strategy notes, and real money. The default trust model is local ownership: your files, your credentials, your broker connections, your decision history.

There is no database to provision. Config, sessions, trading history, news, issues, inbox entries, and workspace artifacts live under ~/.openalice (or OPENALICE_HOME) as JSON, JSONL, Markdown, and git repositories. Broker credentials are sealed at rest.

This also makes the system debuggable. If a packaged app gets stuck, a source install lets you inspect logs, read the files, patch the code, and report a concrete failure.

What It Is Good For

OpenAlice is designed for people who want AI help managing trading work:

• researching companies, sectors, macro themes, and cross-asset moves
• turning recurring research into scheduled issue runs
• maintaining watchlists and tracked entities over time
• summarizing news and market data into durable reports
• reviewing account state and portfolio changes
• optionally proposing trades through an approval-first beta path
• preserving the reasoning trail behind each decision

It is not trying to be a black-box signal seller or a broker-hosted auto-trader. The human remains the account owner and final approver.

Current Boundary

OpenAlice is experimental software in active development. Interfaces are moving, desktop packaging is still young, and the UTA trading stack is especially beta.

The issues / tracked entities / inbox stack is the most stable and useful path today. Treat live broker execution as opt-in, paper-test it first, and do not use live funds unless you understand the risks, can verify the behavior yourself, and are comfortable with the failure modes of beta software.

Ways to Run It

• macOS desktop app - a signed Apple Silicon DMG for the desktop build we dogfood. It is the shortest no-terminal path into Alice on a modern Mac.
• Windows source install - the recommended Windows path today. Clone the repo, run it locally, and keep all state as files under ~/.openalice.
• Source & Dev - the best path for Linux, Intel Mac, contributors, and anyone who wants logs or local patches.
• Docker - run OpenAlice on a server or LAN box when you want a persistent instance.

Next Steps

• Installation Overview - Choose the right run path for your platform.
• Quick Start - Open Alice and run your first research task.
• Issue Board - Track work and schedule recurring runs as markdown issues.
• Tracked Entities - Build the Obsidian-like memory layer for assets and themes.
• Inbox - See how finished work gets delivered back to you.