Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
This page will teach you how to create a Cod3x account
Step 1: Logging In
Start by heading over to app.cod3x.org and connect your wallet to sign in. While there’s also an option to create a Cod3x login ID, we currently recommend using your wallet for a smoother and more secure experience.
Step 2: Creating Your First Agent
After logging in, you'll enter the streamlined Cod3x AI chat interface, your starting point for building onchain trading agents.
There’s no setup complexity. Just type your agent trading intent into the chat, and Cod3x begins crafting an agent optimized for real-time market execution.
Examples:
"Create a scalping bot for ETH perps on Arbitrum."
"Build a DCA agent that trades BTC on Avalanche with low slippage."
"I want an agent that monitors market sentiment and trades accordingly."
Cod3x currently supports perpetual trading on GMX, with native support for Arbitrum, Avalanche and Base (for spot trading). As more integrations go live, your agents will gain access to additional chains and protocols.
During creation, Cod3x transparently walks through its internal logic — from token selection and trading timeframes to execution risk settings and personality profile. You’ll see exactly how your agent is being configured before it goes live.
Once ready, your agent will be:
Assigned a Cod3x wallet
Configured with real-time trade execution logic
Live on supported networks like Arbitrum and Avalanche
If you prefer using ready-made configurations, you can explore the "Discover Agents" section, which offers fully configured templates specifically crafted by the Cod3x team. These include popular setups like XRP trading bots or scalpers.
Each template includes clear descriptions and is immediately deployable. Once chosen, these template-based agents are fully editable, allowing you to further customize them at any point after launch.
Clicking on an agent template will bring you into the trading terminal section where you can continue using your agent cockpit-style by prompting it to trade, analyse the chart, draw TA lines and more, or clicking on the “Advanced” option to customize your tasks manually and control trading or social tasks.
No need to learn strategy syntax or write complex commands. Just talk to Cod3x like you would a teammate:
“I want to trade Bitcoin.” “Help become a millionaire with XRP” “Create a trading task that checks RSI, MACD and longs or shorts ETH based on market conditions.”
Cod3x will instantly build the logic, set up the tools, and schedule the runs.
Want to fine-tune things later? Click the "Strategy" button to open the strategy modal, update indicators, change conditions, or adjust timing with zero stress. No setup docs. No friction.
The simpler your prompt, the smoother the outcome. Let Cod3x do the heavy lifting.
Cod3x agents are designed to learn, adapt, and improve with every run, but that doesn’t mean they’ll always get things right on the first try. Sometimes a trading strategy underperforms. Sometimes a task doesn’t execute the way you expected. That’s where Cod3x’s debugging tools and more importantly, the conversational interface step in.
If something feels off, you can now ask your agent directly what happened, just like you’re chatting with a teammate. You might say:
“Why didn’t you post yesterday?”
“Today’s PnL is awful, what went wrong?”
“Please update the strategy to avoid these kinds of losses.”
The agent won’t just explain what happened, it will take action. Cod3x can analyze your past runs, identify points of failure or misalignment, and update your tasks, strategies, or tone based on the conversation. That means you’re not stuck with static settings or forced to manually reconfigure things. Whether you’re frustrated by poor trading results or just curious about what happened during a specific task, your agent can walk you through the logic step by step and suggest meaningful changes in response.
This conversational loop is now the primary way to manage and improve your agent’s behaviour. But for those who want a deeper, more structured look under the hood, the Runs Interface is still available and powerful.
Within the Advanced dashboard, under the Scheduler tab, every agent task (formerly called “goals”) generates a history of executions, giving you full transparency into what the agent tried to do, which tools it used, and how it performed. Clicking on a past run reveals a complete timeline of execution: the original instructions, the tools called, the logic followed, and the outcome. You’ll see whether each step succeeded or failed, and if something went wrong, you’ll get a breakdown of exactly why, whether it was a missing tool input, a failed API call, or a logic mismatch in the prompt execution.
At the bottom of each expanded run, Cod3x provides intelligent recommendations based on what went wrong. Maybe the trading logic needs to be more conservative, or a tool should be swapped for something more reliable. These suggestions can be accepted right away and will immediately update the relevant strategies or tasks without any manual reconfiguration. It’s debugging built into the workflow, not a separate process.
If you want to go even deeper, raw execution logs are available at the bottom of each run. These show every interaction and decision the agent made during the task, down to plugin-level details and internal success criteria. This level of granularity is useful for power users who want to fine-tune performance or understand why two similar runs led to different outcomes.
And just like in the conversational flow, these insights aren’t just for reading. You can take action instantly. Update your trading strategy. Rebalance your tone. Change how tools are used or how tasks are triggered. It’s all editable on the spot, directly from the agent’s interface.
So whether you’re debugging like a power user or simply chatting with your agent to understand what went wrong, Cod3x gives you full visibility and the power to adapt.
Funding Your Agent
Once your agent has been created, either through a prompt or a template, you can access its full trading terminal by clicking on the agent. This opens the full terminal view where you can fund, manage, and control your agent’s trading behaviour.
Every agent on Cod3x is deployed with its own dedicated smart wallet. This wallet is separate from your personal wallet and used exclusively by the agent to hold collateral, place trades, and cover gas fees. You have full visibility and control over the wallet at all times.
To fund your agent, open the terminal and click the green Fund button in the top right. This will bring up a QR code and the full wallet address for the agent. You can scan the code or copy the address to send funds from any external wallet. Cod3x currently supports trading on the Arbitrum and Avalanche networks using platforms like GMX. We recommend sending at least $100 to $500 worth of ETH or USDC to ensure the agent has enough capital for trading and gas fees.
Your agent will automatically recognize the incoming assets, and you'll see them appear in the Portfolio Tab on the right-hand side of the terminal. Supported collateral includes wETH for long exposure and USDC for stable collateralized positions. The terminal will guide you on which asset is best depending on the position type and market behavior.
If you don’t have on-chain assets ready, Cod3x also supports fiat on-ramping through Onramper. Clicking the On-ramp Fiat button in the agent’s advanced dashboard will open a secure interface where you can purchase crypto using a credit or debit card, Apple Pay, or Google Pay. Once completed, the funds will be deposited directly into the agent’s wallet and displayed in the terminal interface.
To empower your Cod3x agent to actively engage and build influence on social media, particularly on X, you can easily connect your accounts through a straightforward process provided on your dashboard.
First, decide if you'd like your agent to manage an existing X account or create a brand-new account tailored specifically to your agent’s unique brand and personality. If you would like to create a new X account for your agent, follow these steps:
Go to X.com/signup.
Click Create Account
Create your Agent’s X account. For more information, head to this help page: https://help.x.com/en/using-x/create-x-account
Next, head to the Socials tab located on the left-hand side of your dashboard in the Advanced settings. Scroll down to the Twitter Config section, where you’ll be prompted to enter the email address and password associated with your X account. For convenience, you can select the Save Credentials option to retain this information for future sessions.
Important: At this step, ensure your account isn't using an authenticator app for two-factor authentication, as this will prevent successful verification.
After entering your credentials, click the Authenticate button. You'll receive an 8-digit verification code sent directly to your email inbox associated with your X account. Enter this code in the provided modal to complete authentication.
Optional "Automated" Tag:
To have your agent’s posts clearly marked as automated, navigate to your X account settings, click on Account Information, then select Automation. Here, you can input your managing account's details to enable the official "Automated by" tag, enhancing transparency and credibility for your audience.
Once your agent is live and funded, you don’t need to go hunting through menus to give it work, you just talk to it.
The Cod3x chat isn’t just where you created your agent. It’s also where you control it. That means creating tasks, editing strategies, and asking for changes all happen in natural language, right inside the chat.
You might start with:
“Make a daily trading plan for ETH and BRETT.”
“Post price updates every 3 hours if $MOODENG pumps.”
“Create a weekly research loop comparing Curve and Aerodrome.”
Cod3x understands the intent, builds the task logic, sets the schedule, and adds it to your agent automatically. If it needs clarification, it’ll ask.
This kind of chat-driven task creation is the core of the Cod3x workflow. The old method, navigating dropdowns and checkboxes is still there if you want it. But most users won’t need it. You can configure and evolve your entire agent through chat.
Every new agent starts with a small set of preloaded tasks based on the intent and personality you gave it at creation. This gives it immediate functionality, even before you customize anything.
A trading-focused agent might begin with:
Daily market scans
Technical indicator checks
News sentiment reviews
Low-volume sniping alerts
A social-style agent might include:
Daily price commentary
Meme reactions
Token sentiment threads
You can review or modify any of these by saying:
“Show me what this agent is doing every day.”
“Change the BTC scan to twice per day.”
“Pause all meme posting for now.”
Everything updates in real time. You stay in full control.
If you want to build something from scratch without using the chat you can still do that.
Go to your agent’s Advanced dashboard and click Scheduler, then New Task.
You’ll be able to configure:
Task Type: Trading, Social, Research, or Hybrid
Schedule: Daily, hourly, one-time, custom intervals
Description: What the agent should do (this is your natural-language prompt)
Tool usage: What sources or plugins the agent should call
Manual configuration is helpful for complex scheduling, syncing task triggers, or linking tasks together (like having a trading check trigger a post on X). But it’s no longer required for day-to-day usage.
Every task can be adjusted, tested, or removed from the Scheduler tab. Clicking on a task opens its full configuration: schedule, description, last execution history, success/failure status, and debug logs inside the “Goal Actions” button.
You can also duplicate tasks, change tools, or create task chains that trigger each other.
And if you want to experiment without committing?
Just say in chat:
“Test the BTC momentum scan task right now.”
Cod3x will run it once immediately and show the result.
In short, your Cod3x agent is now controlled the same way you control a person: by talking to it. The better your instructions, the smarter it becomes.
Cod3x agents break down tasks into steps and subtasks, providing transparency into how each action is performed. Subtasks serve as a detailed look at what happens within a given step, offering insights into which tool was used, what parameters were applied, the reasoning behind the action, and the data retrieved or executed.
This structured execution allows users to track exactly how decisions are made, what information is processed, and how outcomes are determined, whether it’s trading, market analysis, or social media interactions.
Subtasks are not separate executions but rather a deeper window into how a specific step within a run was carried out. They provide a detailed breakdown of:
Tool Execution – Identifies the specific plugin or function the agent used.
Parameter Inputs – Details the variables that shaped the tool’s output.
Reasoning – Explains why the agent made a particular decision.
Data Retrieved – Shows the results pulled from external sources or generated through internal calculations.
For example, if an agent is executing a market analysis task, it might retrieve key indicators such as price trends, RSI values, MACD crossovers, and Bollinger Bands. Instead of simply providing the final decision, the subtask reveals the full breakdown of why that decision was made.
In some cases, the subtask will display technical analysis results in a structured format, detailing recent price movements, overbought/oversold conditions, and potential trading signals. This provides a clear rationale for trade execution, helping users understand the logic behind their agent’s trading strategy.
Some tasks require extensive data processing, and subtasks will log every relevant detail to ensure full transparency. For instance, when an agent analyzes market conditions, it may outline:
Recent price movements and closing prices.
Momentum indicators like RSI and MACD.
Support and resistance levels using Bollinger Bands.
Key observations, such as whether an asset is in an uptrend or facing bearish pressure.
These details allow users to audit the agent’s thought process and confirm that decisions align with their intended strategy.
Similarly, when an agent executes a trade, the subtask will show:
The chosen order type (market or limit).
The selected asset pair and trade size.
The reasoning behind risk management settings, such as stop-loss and take-profit levels.
By presenting all this information within the Goal History, users gain a complete picture of why and how trades are executed.
Not all subtasks involve analysis, some focus on direct execution. For instance, if an agent places a trade, the subtask will log:
The selected token and exchange route.
The trade size and risk parameters.
The final decision to buy, sell, or hold.
The most important part of this process is the reasoning, which explains why a specific action was taken based on the agent’s evaluation of market conditions. Users can reference this reasoning to validate their agent’s behavior and fine-tune its decision-making if necessary.
Similarly, in social-based tasks, subtasks can capture interactions such as retrieving trending topics or analyzing sentiment on X (Twitter). The breakdown will show:
Which accounts or hashtags were monitored.
The engagement level of retrieved tweets.
The sentiment score of certain discussions.
This allows users to see exactly how their agent is identifying trends and formulating content strategies.
The subtask system serves two critical functions:
It provides full transparency into how agents operate, ensuring users can trust the decisions being made.
It allows for easy debugging and optimization, helping users adjust parameters or refine strategies if an agent isn’t performing as expected.
At the bottom of the Goal History, users can also make quick edits to adjust an agent’s:
Personality and decision-making style.
Social engagement approach.
Trading strategy and execution preferences.
Goal settings for improved precision.
By regularly reviewing subtasks and fine-tuning strategies, users can ensure that their agents operate efficiently, adapt to market conditions, and align with their intended objectives.
The Execution Logs provide an advanced, real-time breakdown of how an agent processes tasks, interacts with tools, and executes decisions. This section is intended for power users who want deeper insights into how the system operates under the hood. By examining execution logs, users can diagnose issues, optimize performance, and better understand how their agent handles tasks at a technical level.
Each log entry represents a specific action taken by the agent, here are some examples:
Workflow Initiation – Logs the initial agent setup, including defined goals and strategies.
Node Execution – Displays when the agent activates specific processing nodes.
Tool Execution – Shows which tools (e.g., market analysis, social media posting, trade execution) were called and what data was retrieved or acted upon.
Completion Assessment – Evaluates whether a given step met its success criteria.
Performance Evaluation – Assesses how well an agent executed a goal, factoring in efficiency, tool utilization, and time metrics.
For example, a trading goal might show:
The agent fetching market data using a price inference tool.
The decision-making process for generating a trade order.
The execution of that trade on-chain.
A completion assessment to confirm whether the execution was successful.
Each action is timestamped, enabling users to trace execution flows and identify potential bottlenecks.
While Cod3x agents are designed for seamless execution, issues can arise due to missing data, incorrect tool initialization, or external service errors. Below are some common errors and their explanations:
Cannot set properties of undefined (setting 'startTime')
Explanation: The agent is trying to reference a task ID that does not exist.
Solution: Ensure that the correct ID is being used for execution.
Cannot read properties of undefined (reading 'message')
Explanation: OpenAI’s API is failing or experiencing overload.
Solution: Retry the request or check OpenAI’s service status.
Cannot read properties of null (reading 'execution_steps')
Explanation: The system expected execution steps to be returned but received none.
Solution: Retry the goal, as the output may not have been properly generated.
Cannot read properties of null (reading 'efficiency_metrics')
Explanation: Similar to execution steps—failed to generate the expected output.
Solution: Adjust the goal structure and ensure all dependencies are initialized.
toolNames.map is not a function
Explanation: The agent attempted to reference a tool that was not properly initialized or does not exist.
Solution: Verify that the tool name is correctly configured and available in the agent’s environment.
For advanced users, the execution logs serve as a real-time debugger, allowing you to:
Pinpoint where failures occur – By reviewing logs step by step, users can identify whether a failure happened at the goal initialization, tool execution, or completion assessment stage.
Optimize tool interactions – If certain tools are misfiring or returning incomplete data, logs can help determine if parameter adjustments are needed.
Monitor execution trends – Performance evaluations in logs provide insight into efficiency, tool utilization, and much more, helping users fine-tune their agent’s strategies.
The Runs Interface provides a comprehensive overview of your agent's execution history, helping you analyze its performance, track errors, and refine its behavior. This feature ensures transparency, allowing you to see exactly how your agent processes goals and interacts with tools in real-time.
To view your agent’s execution history, navigate to the goal you want to inspect and click on the "History" button. This opens the Goal History module, where you’ll find a performance breakdown, detailed execution logs, and recommendations for improving goal success rates.
At the top of the Goal History module, several key performance indicators help assess how efficiently your agent is operating:
Efficiency: Measures how effectively the agent executed tasks based on available resources.
Success Rate: Indicates the percentage of tasks that completed successfully without errors.
Tool Utilization: Shows how efficiently the agent leveraged its plugins to accomplish goals.
Time Efficiency: Evaluates whether the agent completed tasks within an optimal timeframe.
Token Usage Graph: Displays how much compute power was consumed per goal execution, helping users optimize efficiency.
Below the performance overview, you’ll find a chronological list of goal execution runs, ordered by time. Each run is color-coded based on its execution state:
Blue Runs (Live Execution Logs): These logs capture raw execution data in real-time. They are useful for debugging and monitoring what the agent is doing live as it happens. More details on troubleshooting are covered in the Execution Logs and Common Errors section.
Green Runs (Completed Goals): These runs represent fully executed goals, from start to finish.
Each run is also assigned a performance rating, ranging from Beginner to Legendary:
Beginner: The goal did not complete successfully or was halted.
Legendary: Every step executed perfectly with no errors.
Clicking on a run expands it, revealing a structured breakdown of each execution step in the process. This allows you to analyze how your agent handled the task in sequential order. Each step includes:
Execution Status: Whether the step was successful or failed (failed steps are marked in red).
Success Criteria: The conditions the agent needed to meet for successful execution.
Subtasks: Break down complex actions into granular steps.
Tool Utilization: The plugin or tool the agent used for that specific step.
Workflow Status: Indicates whether the execution was halted at this stage.
Completion Status & Missing Requirements: If the step failed, this section outlines what prevented it from executing properly.
Final Assessment: A summary of what happened during that stage of execution.
At the bottom of each expanded run, you’ll find agent-generated recommendations suggesting improvements to enhance execution success. These recommendations may include:
Adjusting task structures for better efficiency.
Refining strategy definitions to align with execution logic.
Enhancing tool selection for smoother automation.
For users seeking deeper analysis, full raw execution logs are available at the very bottom, offering a granular look at every event during the run.
At the bottom of the Goal History module, you'll also find quick edit buttons that allow you to instantly adjust your agent's personality, social strategy, trading strategy, and goal settings. Instead of navigating through multiple menus, this streamlined interface enables you to make real-time modifications based on execution results.
With this structured history system, the agents provide a transparent and data-driven approach to automation, allowing users to refine execution, troubleshoot errors, and continuously improve agent performance.
A quick reference for new users.
Agent
Your AI entity. It trades, posts, analyzes, and operates independently using instructions you provide.
Task / Strategy
A single automated workflow your agent performs. Could be a trading routine, a daily analysis, or a recurring tweet.
Execution
One full run of a task. Includes reasoning, data retrieval, and the final action.
Run
A single instance of a task being executed. Logged in the Runs Interface with full traceability.
Tool
A plugin your agent uses to fetch data, make trades, or interact with the outside world. Think of tools as its hands and eyes.
Step
A building block of an execution. Each run is made of multiple steps, such as “Get RSI,” “Analyze Portfolio,” or “Place Limit Order.”
Subtask
A mini-action within a step, usually attached to a specific tool. These offer granular insights into why a decision was made.
Agent Template
A full plug-and-play AI agent configuration, including its personality, trading rules, and prebuilt tasks.
Task Template
A reusable logic block you can add to any agent. Task templates are standalone strategies (like “Daily Market Analysis”) rather than full personas.
Run Limit
The number of times your agent can execute tasks in a 24-hour period. Based on your plan and model usage.
Credit
A virtual unit that determines how many executions you can afford, based on model costs. High-end models use more credits per run.