How beginners can trade prediction markets with AI agents without giving up custody

An AI agent can trade prediction markets on your behalf while your funds stay in a wallet that only you control. The agent receives a scoped key that lets it place orders denominated in plain US dollars, but it cannot withdraw funds or move capital to an address you have not approved. This means a beginner can experiment with automated prediction market trading without depositing money to a custodial account or giving up ownership of the underlying capital.

What is a prediction market and why automate it with an agent?

A prediction market lets participants take positions on whether a specific event will occur. Prices reflect the market's estimated probability, and binary contracts typically settle at either zero or one hundred cents on the dollar. A beginner might want to automate this because prices move quickly as new information arrives, and an agent can evaluate signals, adjust exposure, and execute orders without manual intervention. The appeal is not about speed alone. An agent can operate continuously, monitor multiple markets, and apply a consistent ruleset that removes emotional decisions. However, automation does not remove risk. An agent can lose money just as quickly as it can make it, and beginners should assume they can lose their entire allocated budget. Prediction markets also have unique mechanics, such as binary payouts and early resolution rules, that differ from stocks or perpetual futures. A beginner should understand these mechanics before adding leverage or automation. Unlike stocks or perpetual futures, prediction markets are usually binary or categorical. A binary market resolves to one of two outcomes. A categorical market might have multiple possible winners. This changes how an agent should size positions and manage correlation. If your agent trades multiple binary markets about the same underlying event, it may be doubling its exposure without realizing it. Beginners should start with one or two uncorrelated markets and only expand after observing how resolution mechanics affect returns.

How does self-custody work with an AI agent?

Felix is non-custodial by construction. Your funds sit in a wallet that you control. The agent receives a scoped key that authorizes it to place trades up to limits you define, but the key cannot withdraw funds to itself or to any address you have not explicitly approved. This is different from traditional custodial setups where you deposit funds to a third party and trust their internal ledger. With an agentic setup, the agent interacts with a prediction market venue through the API, but settlement and fund ownership remain with you. The wallet is yours, the keys are yours, and the agent is a delegate with strictly bounded authority. If you revoke the key, the agent loses access immediately while your capital stays in your wallet. There is no clearing period or withdrawal request to file. You simply rotate or burn the key. For a deeper look at the mechanics, see how AI agents trade across markets without taking custody of your funds. The important point for beginners is that you do not need to trust the agent with your capital. You only trust it with a limited ability to trade within a boundary you draw. When a market resolves, the payout flows to your wallet according to the shares you hold. The agent does not touch this payout because it only has trading authority. You can then decide whether to allocate those winnings to the agent's budget for future trades or to withdraw them entirely. This loop keeps you in control of compounding. The agent cannot decide to reinvest profits beyond its cap unless you explicitly raise the cap.

What controls keep a beginner's funds safe?

Safety is enforced by the infrastructure, not by good intentions. You can set a total budget cap so the agent cannot spend beyond a specific dollar amount. Position limits prevent the agent from concentrating too heavily in a single contract. An exit plan can flatten positions when conditions are met, and a panic or kill switch revokes the key and flattens open exposure. These are not optional features you hope the agent respects. They are enforced by the scoped key and the API. The agent cannot override a budget cap because the key simply lacks the authority to sign a transaction that exceeds it. Beginners should treat these as mandatory. A common mistake is to set a large budget cap because you are confident in the strategy. Confidence is not a control. Hard limits are. You should also distinguish between trading capital and wallet capital. The wallet may hold more funds than the agent is allowed to touch. This separation means a bug or a bad market move can only affect the allocated budget, not your entire holdings. You can read more about risk specifics in what beginners should know about prediction market risk when using AI agents, and about setting boundaries in how to start an AI trading agent with hard limits. Another useful control is a drawdown limit, which can act as a circuit breaker if the agent loses a defined percentage of its allocated budget within a specific timeframe. This is especially important in prediction markets, where news events can cause immediate price jumps from fifty cents to ninety cents or down to five cents. A drawdown limit forces the agent to stop and wait for your review rather than trading into a collapsing market.

How do you read odds and size positions in dollar terms?

Prediction market contracts often display odds in different formats depending on the venue. Some show prices between zero and one, others between zero and one hundred, and payout structures vary. The Felix API normalizes this by letting you size orders in plain US dollars. When you tell the agent to buy fifty dollars of a contract, the API handles the venue-specific contract math. A beginner should still understand that a contract trading at seventy cents implies a seventy percent implied probability if it is a binary market. If you buy at seventy cents and the event occurs, you gain thirty cents per unit of exposure. If it does not occur, you lose seventy cents. Sizing in dollars helps you think in terms of capital at risk rather than abstract units. Never allocate more than you are willing to lose entirely. It is also worth noting that prediction markets can have wide spreads, low volume, and sudden liquidity drops. An order sized in fifty dollars might move a thin market or execute at worse prices than expected. The API reports the actual fill, but you should configure the agent to handle slippage and partial fills. For beginners, it is sensible to start with small dollar sizes while you observe how the agent's orders interact with live liquidity. Remember that fees apply to prediction market trades just as they do in other markets. The API normalizes the contract math, but it does not eliminate venue fees or network costs. A beginner should factor these into expected returns. If you are trading contracts with a small edge, transaction costs can erase it. The agent should account for fees in its expected value calculations. If you do not give it fee data, it may overestimate profitability.

What should you test before authorizing live trading?

Paper trading exists for a reason. Run the agent in simulation until you understand how it interprets signals, places orders, and respects limits. Review how it behaves when a market moves sharply or when liquidity is thin. Before going live, you must explicitly authorize the key for real trading. This is a deliberate step, not a default. You should verify the following before authorizing live trading:

• ·Confirm the budget cap rejects orders that would exceed the limit
• ·Test the kill switch to ensure it flattens positions and revokes the key
• ·Lock withdrawal addresses to wallets you control
• ·Review agent logs for incorrect parameters or ignored instructions
• ·Run the exit plan under paper conditions to confirm it triggers correctly

Only after these steps should you authorize live trading, and even then, start with the smallest budget you can meaningfully test. See a practical checklist for running autonomous trading systems with real money for a structured review. Live monitoring is not optional. Even with hard limits, you should review the agent's activity regularly. Logs show what the agent intended, what the API executed, and how the market responded. This observability helps you distinguish between a bad strategy and a bad execution. If the agent consistently buys at poor prices, the issue may be timing or market impact rather than logic. Correlation risk is another factor to test. If your agent trades several binary contracts that relate to the same macro event, a single news release can trigger losses across all positions. Paper trading lets you observe this correlation without paying for the lesson. Adjust your position limits and total exposure so that correlated markets do not amplify drawdowns beyond your tolerance.

How do you connect an agent and start safely?

Agents connect through MCP tools or the REST API. If you use an MCP client, the agent discovers trading tools as functions it can call. If you use the REST API, your backend sends requests directly. In either case, the first step is generating a scoped key with the specific permissions and limits you want. The agent never sees your wallet private key. It only sees the scoped key, which is useless if stolen because it cannot withdraw funds and is capped by your budget. When you are ready to trade, you authorize the key for live mode. Until then, it routes to paper markets. Beginners using MCP should review the tool descriptions to confirm the agent understands which functions place orders and which simply query data. A well-configured prompt should include instructions to stay within the budget and to check balances before sizing. The REST API offers more direct control if you are building a custom system. In both cases, the architecture is the same. One key, one API, and the funds stay in your wallet. You can revoke access at any time. The authorization step is a deliberate gate. You generate the key, configure its scopes, test it in paper, and then toggle it to live. This toggle is a single action that changes the environment from simulation to real money. There is no ambiguity. If you have not performed this toggle, the key is physically incapable of live execution. This design removes the risk of accidentally deploying a test key to production.