How to start crypto trading with an AI agent as a beginner

An AI trading agent is software that connects to markets through an API and places trades on your behalf according to rules you define. As a beginner in crypto, you can run one through a single API key that controls access to a perps venue or spot market while your funds stay in a wallet you own. The agent can buy, sell, or adjust positions within dollar limits you set, but it cannot withdraw funds or send them to an address you have not approved. This means you can automate exposure without handing over custody of your capital.

What does an AI trading agent do for beginners?

A common misunderstanding is that an AI agent will invent a winning strategy on its own. In practice, the agent is an execution layer. You decide what to trade, when to enter, and how much to risk. The agent then reads market data, submits orders, and manages positions at a speed and consistency that is difficult to sustain manually. For crypto beginners, this separation of strategy and execution is useful. Suppose you want to maintain a fixed allocation between two assets, close a position if a moving average crosses, or simply scale into a long over time. Instead of watching charts and clicking buttons, you describe the logic in plain terms or code, and the agent enforces it. The API normalizes venue specific contract math, so you size orders in plain US dollars rather than lot sizes or notional calculations. The agent does not guarantee profits. It guarantees consistency. It will follow your rules even when the market moves quickly, which can be an advantage or a liability depending on whether your rules are sound. Before you delegate anything, you should understand exactly what the agent is allowed to do. You can review this by checking the scoped permissions attached to your API key. One API and one key can also reach stocks, options, perps, and prediction markets, so the same infrastructure works if you later diversify beyond crypto. How to trade every market type through one API with real money explains how that unification works.

How does non custodial setup work?

Non custodial means the funds remain in a wallet that only you can control. When you create an API key for the agent, you are not depositing crypto into a black box. You are granting a scoped permission that lets the agent trade within boundaries you define. The key is tied to your wallet, but it cannot initiate withdrawals. Withdrawal addresses are owner approved only, which means the agent can never send your money to itself or to an external address that you have not explicitly whitelisted. Even if the agent were compromised, the attacker could only trade within the limits you set, not steal the underlying capital. This design matters because beginners often worry about hacks and rug pulls. In a custodial model, you send money to a platform and hope its security holds. In this model, the platform never holds your funds. The agent operates on top of your own wallet infrastructure. If you revoke the key, the agent loses access instantly. You should still treat the scoped key as a sensitive credential. Store it securely, rotate it periodically, and never embed it in public repositories. The safety model is strong, but operational hygiene remains your responsibility. How to control the risks of non custodial trading with real money covers the setup steps in more detail.

What is the difference between paper and live trading?

Paper trading uses simulated balances and fake executions. It is the right place to start. Before you authorize a live key, you should run your agent against paper markets to confirm that it interprets your instructions exactly as you intend. A typo in a symbol name, a misconfigured dollar size, or an inverted condition can turn a sensible strategy into a broken one. The platform provides paper environments for testing. In paper mode, the agent goes through the same order routing logic but without real money at stake. You can watch how it handles partial fills, slippage, and error responses. This is not a perfect mirror of live markets, but it is close enough to catch structural mistakes. Beginners sometimes treat paper trading like a video game, taking absurd risks because the losses are not real. This defeats the purpose. You should test with the same budget caps, position limits, and entry rules you plan to use live. If you would not run the strategy with real money, the paper results are meaningless. When you are ready to go live, you must explicitly authorize a key for real trading. This is a deliberate step, not a default. Once authorized, every order impacts your actual balance. Crypto markets are volatile. You can lose your entire budget, including the principal, if the market moves against your position and your stops fail or are not set. Treat the transition from paper to live as a serious event, not a toggle.

How do you control risk before the agent starts?

Risk control happens in layers. The first layer is the scoped key itself, which restricts what the agent can touch. The second layer is a set of hard limits that the agent cannot override. Budget caps define the maximum amount of US dollars the agent can deploy. Position limits restrict the size of any single trade. Drawdown limits tell the system to halt trading if the allocated portfolio value drops by a threshold you choose. Exit plans specify how to close positions, whether through take profit levels, stop losses, or time based exits. Finally, a panic or kill switch flattens every open position and revokes the API key in seconds. These limits are not suggestions. They are enforced by the infrastructure, not by the agent. If the agent tries to submit an order that exceeds the cap, the request is rejected. If the drawdown limit is hit, the agent is paused. This architecture is important because software bugs and market gaps can happen faster than a human can react. You should also think about correlation. A crypto agent might hold multiple altcoins that move together. A position limit on each individual coin does not protect you from a portfolio wide collapse if the entire market drops. Set both per position limits and total portfolio exposure caps. Before you launch, walk through a checklist. Confirm your wallet balance. Verify the withdrawal whitelist. Test the kill switch in paper mode. Review the exact dollar sizes and symbols the agent is allowed to trade. How an AI agent trades perpetual futures within hard limits it cannot cross and A practical checklist for running autonomous trading systems with real money offer deeper guidance on building this safety stack.

How do you connect an agent to your strategy?

You have two main paths. The first is through MCP tools, which let Claude, Cursor, or other MCP clients call trading functions directly. This is often the fastest way to experiment because you describe the strategy in natural language and the agent translates it into API calls. The second path is the REST API, which you call from your own code. The exact request schema is in the docs; the shape looks like this:

curl -X POST "https://api.felix.trade/..." \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "market_type": "crypto",
    "side": "buy",
    "dollar_size": 100,
    "symbol": "BTC"
  }'

In either case, you define the strategy, and the agent executes. MCP is useful for prototyping and for traders who prefer to reason aloud about their logic. The REST API is better for deterministic, high frequency, or complex multi step strategies that need precise control. Both paths use the same safety layer of scoped keys and budget caps. If you are a beginner, start with MCP. You can iterate on your logic in a chat interface, watch the agent explain what it plans to do, and approve or reject actions before they reach the market. This human in the loop mode reduces the chance of misunderstanding. Once you trust the logic, you can let the agent run autonomously within the hard limits you have already set.

What should you monitor once the agent is running?

Automation does not mean abdication. After the agent starts, you should monitor your equity curve, open positions, and whether the agent is approaching any of its hard limits. Most problems do not look like catastrophic hacks. They look like slow bleed from a logic error, a symbol mismatch, or a strategy that made sense in backtests but fails in current conditions. Check the logs regularly. Look for rejected orders, repeated retries, or unexpected position sizes. If the agent is supposed to hedge but ends up net long, that is a signal to pause and review. Markets change. A strategy that worked during low volatility can unravel during a sharp move. You should also verify that your kill switch still works. Once a month, or after any infrastructure change, test revoking the key in paper mode to confirm the revocation path is intact. If you need to intervene, the panic switch should flatten positions and disable access without delay. Remember that trading can lose money, including everything you allocate to the agent. There is no insurance for a bad strategy. The guardrails limit the speed and scale of losses, but they cannot eliminate the risk of being wrong about market direction. Stay involved. The goal of an AI agent is to execute your plan consistently, not to remove you from the decision making process entirely.