How does an AI agent trade stocks?

An AI agent can trade stocks by connecting to a stock broker through an API and executing buy or sell orders on your behalf. It does not hold your cash or shares. It simply sends instructions within boundaries you define, and you remain the owner of the account. The agent cannot withdraw funds to itself or to any address you have not approved.

What does an AI stock trading agent actually do?

At its core, an AI stock trading agent is a program that reads market data, applies a strategy, and generates orders. The program runs on a server or your local machine, and it communicates with a stock broker through an API. When the strategy says buy or sell, the agent formats an order and sends it. The broker receives the order, checks your account, and executes the trade. The agent never touches the shares or cash directly. It only sends messages.

The intelligence part can take many forms. Some agents follow hard rules, such as buying when a moving average crosses above another. Others use statistical models or machine learning classifiers. More recently, large language models can parse news or earnings transcripts and output trading decisions. In every case, the agent is only as good as the logic behind it. There is no secret sauce that guarantees profit, and the agent does not have insider knowledge or special market access.

The agent can operate continuously. It can monitor prices while you sleep, rebalance a portfolio on a schedule, or flatten positions when a stop level is hit. This autonomy is useful, but it also means mistakes can compound quickly if the strategy is flawed or the data is bad. That is why the infrastructure around the agent matters as much as the agent itself.

How does the agent connect to a stock broker?

Traditionally, placing a stock trade meant logging into a brokerage website and clicking buttons. An agent replaces those clicks with structured API requests. The broker exposes an interface that accepts orders, cancels, and queries for balances. The agent holds a credential, usually an API key, that proves it is authorized to act on your account.

Felix simplifies this by offering one API and one key that covers stocks alongside other market types. Instead of integrating with each broker separately, your agent speaks to Felix, and Felix normalizes the interaction with the underlying stock broker. This reduces the integration work and keeps the agent's code simple. The exact request schema is in the docs; the shape looks like a standard REST call with a symbol, side, and amount in US dollars.

Because the agent connects through an API, you can also link it to tools you already use. Agents can connect through MCP tools from Claude, Cursor, and other MCP clients, or you can call the REST API directly from your own code. Trading over MCP from Claude, Cursor, and Codex explains how that integration works in practice.

The important architectural detail is custody. In a non-custodial setup, your funds sit in a wallet or brokerage account that you control. The agent can spend within limits, but it can never withdraw to itself or steal. How an AI agent executes orders while you keep full custody walks through the mechanics of this design.

What safety controls keep your money safe?

Autonomy without guardrails is dangerous. A bug or a bad model can send orders that drain an account. Felix provides several layers of safety controls that sit between the agent and the market.

First, scoped keys let you restrict what the API key can do. You can limit it to trading only, disable withdrawals, or restrict it to specific symbols. If the key leaks, the attacker cannot sweep the account.

Second, budget caps and position limits define how much the agent can spend. You might set a daily maximum of one thousand dollars, a per position cap of five hundred dollars, and a total position count of ten. Once a limit is hit, the API rejects further orders.

Third, exit plans and drawdown limits automate risk management. You can configure stop losses, time-based exits, or portfolio level drawdown thresholds that trigger a halt. How to set spend caps and drawdown limits for trading agents covers the details of configuring these boundaries.

Fourth, a panic or kill switch lets you revoke access instantly. If the agent behaves strangely or market conditions shift, you can flatten positions and disable the key in one action. Live trading also requires explicit owner authorization of a key, so an agent cannot accidentally or silently switch from paper to real money. These controls do not eliminate risk. They contain it.

How do you tell the agent what to trade?

You define the strategy. The agent is a vessel for your logic, not a replacement for your judgment. You might write a Python script that calculates relative strength, you might prompt an LLM to read earnings reports, or you might configure a simple rebalancing rule. The agent translates that logic into orders.

One practical convenience is order sizing in plain US dollars. Instead of calculating lot sizes, multipliers, or fractional share math for each broker, you tell the agent to buy one hundred dollars of a stock. The API normalizes the venue-specific contract math behind the scenes. This makes strategies easier to write and less prone to unit errors.

You also define the universe. The agent should know which tickers it is allowed to trade. You might restrict it to a handful of large cap names, or you might allow any symbol but cap the exposure per name. Suppose you want the agent to maintain equal weights in five technology names and rebalance every Friday. You specify the tickers, the target weights, the rebalance frequency, and the maximum order size. The agent does the rest.

It is worth repeating that the agent does not generate alpha simply because it is automated. A bad strategy coded into an agent will lose money faster than a bad strategy executed manually. The value of the agent is execution speed, consistency, and removal of emotional decisions, not magical predictive power.

Can you test the agent before it uses real cash?

Yes, and you should. Felix offers paper trading so you can observe the agent's behavior without risking capital. Paper trading mimics the order flow and bookkeeping of live trading, but it uses fake money. It is the right place to discover bugs, test the kill switch, and verify that your strategy logic does what you expect.

Backtesting is also useful, but it is easy to fool yourself. You might overfit to past data, ignore transaction costs, or use information that would not have been available at the time of the trade. How to backtest AI trading strategies without fooling yourself explains how to avoid these common traps.

When you are ready to go live, the transition is intentional, not automatic. You must explicitly authorize the key for live trading. This step exists so that an agent tested in a sandbox cannot accidentally send real orders. Even after authorization, start with small size. Paper profits do not guarantee live profits, and market impact, slippage, and partial fills behave differently when real money is on the line.

What risks remain even with good controls?

Safety controls limit the blast radius, but they cannot remove market risk. Stocks can go down. A strategy that looked brilliant in backtesting can fail in live trading because market regimes change. The agent can lose money, including everything you allocate to it, and you should never trade with capital you cannot afford to lose.

Model risk is another concern. The agent might misinterpret a signal, double order because of a retry bug, or hold a position through a gap down because the exit rule was too slow. Connectivity issues can delay orders or leave the agent blind during a fast move. Slippage means the price you get may differ from the price that triggered the decision.

There is also operational risk. API keys can leak. Servers can crash. Data feeds can stall. If the agent depends on an external model or service, that service can fail or change its behavior. A kill switch helps, but only if you are monitoring the agent and can reach the switch.

Because of these risks, it makes sense to treat an AI trading agent as a tool for disciplined execution rather than a source of guaranteed returns. The agent removes hesitation and fatigue, but it also removes the human pause that might stop you from acting on a flawed signal. Automation amplifies both good and bad decisions.