Connect
The Robinhood Trading MCP ships as a featured preset. Authorize over OAuth and its tools load without a gateway restart.
TOKEN-EFFICIENT AI AGENT
Local-first agentic trading,minimum tokens.
AgentOS trades natively, routes every turn to the cheapest capable model, and keeps your keys, memory, and routing on your own machine.
3 surfacesCLI, Web UI, and chat on one runtime
20+ providersSwitch backends without code changes
On-deviceRouting and embeddings stay local
LOCAL-FIRST AGENTIC TRADING
Your agent can trade, not just talk about it.
Trading is a first-class capability, not an afterthought. Market data, portfolio analysis, and order execution reach the agent through partner-authorized connections and skills that ship with AgentOS — all running on your own machine.
STREAMABLE HTTPOAUTHSCHEMA-VERIFIED TOOLS
Analyze
Read positions, balances, order history, and watchlists, or research a token's liquidity, holders, and security profile.
Preview
Order-capable tools are treated as high-impact. Writes are previewed and surfaced for approval before anything is sent.
Execute
Confirmed orders run through the provider's own authenticated schemas — never an unofficial API.
Robinhood Agentic Trading
Account and portfolio analysis, market research, order preview, placement, cancellation, and rebalancing over the official Trading MCP.
GMGN on four chains
Swap, batch-trade, and set limit, stop-loss, take-profit, and trailing orders across Solana, BSC, Base, and Ethereum.
Tokenized stocks (RWA)
Resolve a company or ticker to its Robinhood Chain token — contract address, chain id, and decimals — from the public CoinGecko list.
Bankr
Natural-language trading for crypto and tokenized stocks, wallet and P&L reads, transfers, and token launches across Base, Solana, Robinhood Chain, and more.
Local-first, where it matters most.
What still leaves the machine is exactly what has to: the broker or exchange calls themselves, and the model turns you route to a remote provider.
Credentials stay on the device
Authorization tokens are written to a 0700 directory on POSIX systems, and Windows uses your own state-directory ACL. Signing keys are local environment values — nothing is escrowed with a hosted service, and the agent never asks you to paste one into chat.
The routing decision never leaves
The Pilot Router classifies each turn on-device, so a strategy prompt is not shipped to a third party merely to decide which model should handle it. Only the turn that actually runs reaches your chosen provider.
Always-on runs on your own hardware
Scheduled and recurring strategies execute through the local gateway instead of a rented agent cloud. Paired with router-driven model selection, running continuously stays inexpensive.
Every turn earns the right model.
A local signal pass and a small judge model choose the cheapest capable tier before execution starts.
Read the message
The full turn is classified by difficulty, risk, context, and intent.
Extract signals
Local rules identify debug work, strict formats, long context, and agentic tasks.
Judge the tier
A small model selects the lowest tier that can complete the work reliably.
Run the model
The chosen tier maps to a concrete provider profile for that turn.
R0Trivial
Greetings and one-liners
R1Simple
Routine edits and focused tasks
R2Hard
Refactors and non-trivial debugging
R3Critical
Production and cross-service work
Guardrails keep routing stable.
Anti-downgrade
Recent higher-tier turns stay warm, protecting continuity and model cache reuse.
Sticky tier
Short follow-ups inherit the active workstream instead of dropping context.
Complaint up
A failed answer raises the next turn instead of repeating the same attempt.
One runtime. Three ways in.
CLI, Web UI, and chat share the same gateway, memory, tools, approvals, and usage accounting.
The CLI you already live in
Configure a provider, start the gateway, and run full agent turns from the shell.
# configure a provider once
$ agentos onboard
# start the local gateway
$ agentos gateway run
✓ gateway live on 127.0.0.1:18791
✓ router: recommended (on-device)
✓ memory + embeddings ready
Web UI
Run sessions, review approvals, publish artifacts, and inspect replay data.
Chat channels
Bring the same runtime into the messaging tools your team already uses.
Built for long-running usefulness.
Memory persists, tools stay controlled, and context remains focused across extended workstreams.
Tool-result compression
Large outputs stay useful without flooding model context. Full results remain available on disk.
Personal memory
Facts, notes, and task traces return through local keyword and semantic search.
Layered sandbox
File, shell, web, git, and media tools run behind policy and approval layers.
Meta-skills
Package recurring work as reusable, composable routines.
Durable sessions
Transcripts, summaries, artifacts, cost, and replay data persist.
Built-in web search
Bring fresh external context into any turn through a configured provider.
On-device embeddings
Local ONNX embeddings power semantic recall without sending memory to a remote model.
One schema. Every provider.
Point AgentOS at the backend that fits the work. Switching never requires application code changes.
OpenCAPOpenRouterOpenAIAnthropicGeminiDeepSeekDashScopeOllamaQwenMiniMaxOpenCAPOpenRouterOpenAIAnthropicGeminiDeepSeekDashScopeOllamaQwenMiniMax
Running in minutes.
Windows, macOS, and Linux use the same setup path.
Install uv
AgentOS installs into an isolated tool environment and manages its own Python, so you don't need Python first.
curl -LsSf https://astral.sh/uv/install.sh | sh. "$HOME/.local/bin/env"
Install AgentOS
Pull the recommended profile — router plus the on-device memory stack — from the latest release wheel.
uv tool install --python 3.12 "use-agent-os[recommended]"
Connect a provider
Run the onboarding wizard to pick a backend and set your key, or point it straight at one non-interactively.
agentos onboard# non-interactive:agentos onboard --provider openrouter \ --api-key-env OPENROUTER_API_KEY
Run the gateway
Start the shared runtime that every surface connects to, then open the local control console in your browser.
agentos gateway run# → http://127.0.0.1:18791/control/
Run your first turn
Chat interactively, or fire a single one-shot turn. Smart routing sends each turn to the cheapest capable model.
agentos chat# or one-shot:agentos agent -m "Summarize the README here"
Questions worth answering.
Does AgentOS support agentic trading?
Yes. Trading is a first-class capability. AgentOS ships a featured Robinhood Trading MCP preset plus bundled skills for GMGN swaps and market research across Solana, BSC, Base, and Ethereum, Robinhood tokenized-stock lookups, and Uniswap V4 liquidity management. Partner skills from Bankr and Capminal install in one click from the Community hub.
How does AgentOS place a trade safely?
Order-capable tools are treated as high-impact financial actions. The agent reads the provider's live authenticated schemas rather than an unofficial API, execution skills require explicit confirmation, and liquidity writes stay a dry run until you approve the exact plan.
Does AgentOS run locally?
Yes, it is local-first. Authorization tokens are stored in a permission-restricted directory on your own machine, signing keys are local environment values, the Pilot Router classifies every turn on-device, and scheduled work runs through your local gateway rather than a rented agent cloud. What leaves the machine is only what has to: broker or exchange API calls, and the model turns you route to a remote provider.
What makes AgentOS token-efficient?
An on-device Pilot Router classifies every turn locally by difficulty, risk, context, and intent, then a small judge model selects the lowest tier that can complete the work reliably. Tool-result compression keeps large outputs out of model context.
Where can I run AgentOS?
On one runtime across three surfaces: a CLI, a local Web UI control console, and chat channels including Telegram, Slack, and Discord. All of them share the same gateway, memory, tools, approvals, and usage accounting.
Which model providers does AgentOS work with?
More than 20 provider backends, including OpenAI, Anthropic, Gemini, OpenRouter, and local models through Ollama. Switching backends needs no code changes.
The team behind the runtime
Builders, not a brand deck.
A small crew at 404 Labs ships AgentOS end to end: routing, memory, sandbox, and the surfaces you run it through.
View the full team
Run more. Spend less.
Route each turn to the lowest-cost model that can complete it reliably.
Install AgentOS