Funding your Cod3x agent is straightforward and can be done directly from your agent's dashboard. You have two primary methods available: on-chain deposits or fiat on-ramping.

On-Chain Funding

To fund your agent on-chain, navigate to the agent dashboard and locate the address under the description on the left side of your screen. Click the clipboard icon to quickly copy your agent’s unique wallet address, or press the “Fund Agent” button to reveal a scannable QR code and the address itself. You can then transfer assets from your existing wallet to your agent’s wallet address.

Cod3x currently supports the Base network. You're free to choose any supported asset to fund your agent, but we recommend including at least $6 worth of ETH on the Base network to cover gas fees.

Fiat On-Ramp Funding

If you prefer using a credit or debit card, or payment methods like Apple Pay or Google Pay, click the “On-ramp Fiat” button. You’ll be redirected to Onramper’s secure interface, where you can select your preferred payment method and complete the transaction.

After completing the funding process, your transferred assets will appear in your agent’s "Managed Assets" section on the dashboard, ready for use.

Step 1: Logging In

Step 2: Choosing Your Creation Path

Once you're logged in, you’ll be asked how you’d like to create your agent.

You can either go with the Simple Creation Tool, which is fast and intuitive, or dive into the Advanced Creation process, where you’ll configure every detail yourself. Each path leads to the same place—your agent dashboard—but the experience getting there is different depending on your preference.

➤ If you chose Simple Creation:

Simple Creation is designed for users who want to get started quickly with as little friction as possible. You’ll be asked to name your agent and, optionally, provide a short background story. This can be playful, serious, technical, or completely fictional—whatever feels right for the kind of agent you want to create.

Beneath that you’ll find a curated set of pre-built agents created by the Cod3x team. These templates each come with their own trading and social strategies, personality configuration, and a full set of pre-scheduled goals.

Clicking on a template reveals everything under the hood—from the agent’s tone of voice to its mission goals. Each one is labeled by difficulty and intent, so you’ll know whether it’s more suited for trading, social content, research, or hybrid behavior.

Once you've reviewed and selected a template, simply click Create Agent, and your new bot will be deployed. Cod3x will automatically set up a wallet for your agent and take you straight to your dashboard where you can begin scheduling tasks, funding the wallet, or monitoring activity.

Note: Simple Creation doesn’t mean your agent is locked in. Every template can be edited and reconfigured after launch. You’re free to evolve your agent over time—refining its tone, tweaking its trading behavior, or replacing its goals entirely. Think of this flow as a jumpstart, not a constraint.

➤ If you chose Advanced Creation:

Advanced Creation is for users who want to fine-tune every aspect of their agent’s identity and behavior from the very beginning. This process gives you control over everything: from how your agent talks, to how it trades, to what kind of tone it uses in tweets and replies.

You’ll begin by defining your agent’s core identity. Start with a name, then provide a backstory or character summary. This helps shape your agent’s voice, especially in social tasks.

Next, you’ll select an archetype. This determines your agent’s high-level personality framework—options include teacher, analyst, expert, peer, or even troll. Once you’ve selected an archetype, you’ll move into configuring its detailed personality profile using the Five-Factor Model. You’ll adjust sliders for traits like Openness to Experience, Conscientiousness, Extraversion, Agreeableness, and Neuroticism. These values shape how your agent responds in public, how it interprets prompts, and how it engages in both trading and social contexts.

After personality comes social strategy configuration. Here you’ll decide what kind of tone your agent uses, what types of content it generates (e.g. market updates, memes, sentiment analysis), and how it interacts with other users. This determines whether your agent comes off as formal and informative, casual and meme-y, or somewhere in between.

Finally, you’ll define your trading strategy. Select the tokens your agent will interact with, the trading timeframe (e.g. intraday vs swing), risk tolerance, and general execution style. These settings directly guide the logic your agent will follow when placing trades.

Once all sections are complete, hit Create Bot. Cod3x will generate a new wallet for your agent and deploy it immediately. You’ll be redirected to the dashboard, where your agent is ready to begin executing your configured strategy.

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.

Next, head to the Socials tab located on the left-hand side of your dashboard. 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.

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. You will receive an email from X that there's a new device login, this is perfectly fine.

Important: At this step, ensure your account isn't using an authenticator app for two-factor authentication, as this will prevent successful verification.

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.

At its core, prompting is the process of communicating with AI using structured inputs to guide its response. Just like giving instructions to a human, the quality, clarity, and intent behind a prompt significantly impact the output.

AI models, including large language models (LLMs), operate on patterns rather than explicit understanding. They generate responses by predicting the most likely continuation of a given input based on extensive training data.

Effective prompting involves three key principles:

1. Clarity – The more specific and well-structured a prompt, the more accurate and relevant the response will be.

2. Context – Providing relevant background information helps the AI align its response with user intent.

3. Constraints – Setting boundaries (such as format, length, or structure) ensures outputs meet specific needs.

Types of Prompts

1. Open-Ended Prompts – These invite broad, exploratory responses and allow the AI agent to determine the best approach.

   • Example: "Find the best way to increase my stablecoin yield with low risk."

2. Instruction-Based Prompts – These provide clear, specific tasks for the AI agent to execute.

   • Example: "Swap 50% of my USDC into ETH and deploy it into a lending protocol."

3. Few-Shot Prompts – These offer examples to guide the AI’s execution strategy.

   • Example: "Last time, you found a 5% APY stablecoin yield on Frax. Find me a similar opportunity today."

4. Chain-of-Thought Prompts – These encourage the AI to break down a task into logical steps before executing.

   • Example: "Analyze my portfolio, identify underperforming assets, suggest a rebalancing strategy, and execute if the projected yield improves by at least 2%."

5. Declarative Intent Prompts – These define a goal without specifying the method, allowing the AI to determine the best approach.

   • Example: "Optimize my portfolio for passive yield farming with minimal active management."

By structuring prompts effectively, Cod3x AI agents can navigate complex DeFi tasks, execute financial strategies, and continuously refine their decision-making processes based on user-defined goals.

Once your Cod3x agent is funded and your X account connected, it's time to set tasks and watch your agent come to life.

Begin by navigating to the Scheduler tab located on the left-hand side of your dashboard. You'll first encounter the List View, which displays all your scheduled tasks clearly. If you prefer a calendar-based layout, you can easily switch to the Calendar View. Here, you'll also see your agent's daily, weekly, and one-time task limits. Currently, each execution, or "Run," is limited to 100 per 24 hours.

To set up new tasks, head to the right side of the Scheduler tab, where you'll find two main options: Templates or New Task.

Templates

Clicking on Templates in your Scheduler tab now opens a dropdown with three distinct options: Goals, Agents, and Create Agent Template. Each one is designed to help you either jumpstart your agent or streamline the scheduling process using pre-made logic and configurations.

Selecting Goals will bring up a curated list of pre-configured task templates crafted by the Cod3x team. These templates are categorized into Trading, Research, Social, and Hybrid types, allowing you to quickly filter based on the kind of outcome you’re aiming for. For example, if you want your agent to hunt for technical setups, choose from the Trading tab. If you're trying to build influence or engage in conversation on X, head to the Social section.

Clicking on any goal template will expand it to reveal more information. You’ll see the core prompt that drives the task, its default schedule, difficulty level, and which tools it relies on to complete the job. When you're ready, clicking Use Template will automatically add that goal to your Scheduler, where you can then adjust it just like any manually created task.

Beyond individual goals, you can now select full Agent Templates. These are pre-built agents that come equipped with everything—from personality, trading style and social engagement, to a bundle of predefined goals. When selecting an Agent Template, you’ll be presented with a full preview including the agent's bio, strategy description, and the goals that come with it. These templates are also sorted by category and difficulty, so you can quickly scan for beginner-friendly setups or more advanced Agent.

Once you’ve chosen an Agent Template, you’ll be asked how you’d like to apply it. You can either create an entirely new agent based on the template, inject the new goals into your current agent without changing its core personality, or overwrite your agent’s current goals while keeping its base configuration intact. This level of flexibility allows you to adopt as much or as little from the template as you'd like.

Lastly, if you’ve built an agent that you want to reuse later—or simply share across accounts—you can create your own custom template. Clicking on + Create Agent Template allows you to take a snapshot of your current agent’s configuration, including its personality, strategies, and goals. You’ll then be prompted to give it a name, choose an icon, and assign a color for easy reference. Once saved, your new template will appear in the Simple Creation section whenever you’re spawning a new agent.

While these templates offer a fast way to get started, it’s important to remember that every user’s needs are unique. Each one can be edited, extended, or tweaked to match your own objectives and tone.

Note: These templates are built and vetted by the Cod3x team as high-quality starting points, but you're always encouraged to evolve them based on your own trading style or social voice.

Creating Tasks from Scratch

If you prefer full control over your agent’s behavior, you can click the New Task button to start from a blank slate. This option allows you to define every aspect of your goal from the ground up—including its name, intent, schedule, and the tools your agent will use to complete it.

The first step is to choose the goal type, which helps the underlying AI understand the context of your task. For example, selecting Trading will automatically pass token-related information to your agent, like what tokens it can access and how they’re allocated. If you select Social, these trading details are excluded entirely. This distinction is important—it ensures your agent runs more efficiently by only processing the relevant data.

Next, you’ll give your task a Title. This is simply for your own reference and won’t affect how your agent behaves.

Then comes the most important part: the Description. This is where you explain, in your own words, what you want your agent to do. A good description provides specific context and actionable instructions that fit within your agent’s broader trading or social strategy. Your agent will automatically reference its style and personality while interpreting the task, but the more clear and detailed you are, the better the performance will be.

Instead of just saying “buy Bitcoin” for example, try expanding your thinking to include steps that involve decision-making. IE. you might ask your agent to:

Get the latest technical indicators for Bitcoin

Assess how they line up with your strategy

Identify strong entry points based on that alignment

Generate proposed trades

Evaluate if those trades match your risk profile

And finally, execute the orders if everything checks out

Framing your instructions this way helps the agent “think before acting,” making it far more intelligent in how it handles the task. It can propose an idea, evaluate whether that idea is solid, and then act on it—just like you would.

Once your description is entered, the Cod3x system will generate a dynamic execution plan. This plan includes a high-level goal, broken down into tasks, and each task includes its own success criteria. From there, your agent will generate more specific subtasks, often tied directly to individual tools. These are smaller, more focused actions that chain together to complete the full workflow.

Ultimately, the level of control you have in this flow means your task can be as broad or as precise as you need. And because the AI builds everything around the context you give it, your description plays a powerful role in shaping how the agent interprets and executes each goal.

Managing and Testing Your Tasks

Clicking on any task in your scheduler opens a detailed view of your goal, allowing you to adjust or fine-tune goal configurations, edit your schedule, pause or delete goals, duplicate your goals, edit your tools, configure input sources and output destinations or initiate an immediate test run. Note that testing a goal instantly triggers its full execution and consumes available runs.

To review task performance or troubleshoot issues, use the History button within the task details. For deeper insights on reviewing and debugging your agent's activities, refer to the dedicated "Debugging Your Agent" module.

Effective decision-making in AI-driven finance depends on context awareness—the ability to understand past interactions, current conditions, and future goals. Cod3x AI agents construct and maintain context dynamically, ensuring that each action aligns with the user’s objectives and the evolving DeFi landscape.

What is Context in AI?

Context in AI refers to the relevant information an agent considers when making decisions. This includes:

1. User History – Past interactions, preferences, and executed strategies.

2. Current Market Conditions – Real-time blockchain data, asset prices, liquidity, and risk metrics.

3. Defined Goals – The user's intent, constraints, and execution requirements.

4. Execution Logs – A record of past AI actions, successes, and failures for refinement.

How Cod3x Builds Context

Unlike standard AI models that handle each prompt independently, Cod3x AI agents construct context through persistent data structures and active reasoning loops.

1. User Profile Memory

   • The system remembers past interactions, token preferences, and risk tolerance.

   • Example: If a user regularly stakes stablecoins, the AI prioritizes stablecoin-based yield strategies.

2. Dynamic Data Retrieval

   • Cod3x agents fetch real-time DeFi data from protocols, checking liquidity, APYs, and gas costs.

   • Example: Before suggesting a lending strategy, the AI verifies that the lending pool has sufficient liquidity and a sustainable yield.

3. Task-Specific Context Construction

   • Each new request builds upon past decisions, ensuring cohesion and efficiency.

   • Example: If a user asks, “Find a better yield than my current strategy,” the AI remembers the current yield benchmark and searches accordingly.

4. Execution History & Adjustments

   • Agents track successful and failed actions, refining strategies over time.

   • Example: If an attempted yield farming strategy failed due to high slippage, the AI avoids similar setups in the future.

5. Multi-Step Reasoning & Intent Matching

   • Cod3x agents don’t just retrieve data—they interpret goals, weigh multiple options, and select the best path.

   • Example: If a user says, “Optimize my portfolio,” the AI analyzes holdings, compares yield options, and suggests an action plan rather than just providing data.

Why Context Matters in Cod3x

Without context, AI-driven automation in DeFi would be fragmented and inefficient. Cod3x’s ability to construct and retain context allows it to:

• Make intelligent, informed decisions instead of reacting in isolation.

• Minimize redundant work by understanding what has already been attempted.

• Adapt to changing market conditions without requiring constant manual intervention.

• Improve user experience by personalizing financial strategies based on past actions.

By combining memory, real-time data, execution tracking, and goal-oriented reasoning, Cod3x AI agents construct a deep contextual framework—transforming them from simple query responders into autonomous financial strategists.

Cod3x AI agents don’t just respond to single prompts—they learn, adapt, and refine their decision-making by creating and managing persistent memory. This allows them to maintain long-term awareness of user preferences, past actions, and evolving market conditions, making their responses smarter and more tailored over time.

How Cod3x Creates New Memories

Cod3x agents generate memory through structured logging, pattern recognition, and intent mapping. Every interaction feeds into the system, ensuring continuous improvement without requiring users to re-explain their strategies.

1. User Preferences & Behavior Tracking

   • The agent remembers key user preferences, such as risk tolerance, trading assets, and strategy types.

   • Example: If a user consistently chooses low-risk yield farming strategies, the agent prioritizes similar options in future recommendations.

2. Executed Actions & Past Decisions

   • The system logs completed trades, staking actions, and lending positions to track progress.

   • Example: If a user swaps USDC for ETH and later asks for “another good swap,” the agent avoids suggesting the same trade unless conditions have changed.

3. Market Conditions at Time of Execution

   • Every past decision is stored alongside the market conditions at that time, allowing for historical performance analysis.

   • Example: If a user asks why a past trade underperformed, the agent can recall gas fees, slippage, and market fluctuations at the moment of execution.

How Cod3x Manages Memory Efficiently

Memories must be relevant, structured, and retrievable—Cod3x avoids cluttered or unnecessary data while maintaining critical insights for financial automation.

1. Hierarchical Memory Structure

   • Short-term memory: Active sessions, recent queries, and immediate execution steps.

   • Long-term memory: Past transactions, user-defined preferences, and strategic trends.

   • Example: If a user asks, “What’s my current strategy?” the agent references long-term memory; if they ask, “What was the last thing I did?” the agent pulls from short-term memory.

2. Memory Updates & Refinement

   • The system continuously refines memory based on new user inputs and market shifts.

   • Example: If a user updates their risk preference from moderate to aggressive, past recommendations are re-weighted to align with the new strategy.

3. User-Controlled Memory Overrides

   • Users can override or reset AI memory when they want a fresh perspective or strategy shift.

   • Example: A user can clear previous yield farming preferences if they decide to focus on liquidity provision instead.

Why Memory Matters in Cod3x

Without memory, AI-driven automation would be reactive and repetitive. By creating and managing memories, Cod3x AI agents become proactive financial assistants, able to:

• Improve strategy consistency – Align actions with past decisions to maintain financial coherence.

• Reduce redundant explanations – Avoid asking users for information they’ve already provided.

• Adapt dynamically – Shift strategies based on evolving market trends and user behaviors.

• Provide historical insights – Offer data-driven explanations for why certain strategies succeeded or failed.

Cod3x isn’t just an AI interface—it’s a living, evolving system that grows alongside its users, ensuring every decision is backed by historical awareness and strategic intelligence.

Cod3x AI agents don’t rely on static, one-size-fits-all responses. Instead, they use dynamic prompting, a system that adapts in real-time based on user context, past interactions, and live market data. This ensures that every AI-generated response is precise, relevant, and actionable.

What is Dynamic Prompting?

Dynamic prompting is the process of modifying a prompt on the fly to optimize AI performance. Instead of treating each user request as an isolated input, Cod3x agents:

1. Retrieve relevant past interactions – Ensuring continuity in ongoing financial strategies.

2. Incorporate real-time market data – Adjusting recommendations based on the latest conditions.

3. Refine task execution based on previous successes and failures – Avoiding redundant or suboptimal actions.

By dynamically enhancing and restructuring prompts, Cod3x ensures that AI agents always respond with the most informed and effective strategy.

How Cod3x AI Uses Dynamic Prompting

1. Context-Aware Query Expansion

   • Instead of responding to broad queries with generic answers, the agent reframes the question to maximize precision.

   • User: “Find me a good yield opportunity on my BTC.”

   • Agent (Expanded Prompt): “Find a yield opportunity for BTC that offers at least 5% APY, aligns with the user's historical risk preference, and supports assets they currently hold.”

2. Live Data Injection

   • AI agents dynamically pull market data before forming a response.

   • User: “What’s the best yield for stablecoins?”

   • AI (Expanded Prompt): “Check current stablecoin lending rates on Aave, Frax, and Convex. Compare yields, assess protocol security, and prioritize strategies with sustainable returns.”

3. Multi-Step Reasoning

   • Instead of providing just an answer, the agent thinks through the problem step by step.

   • User: “Optimize my portfolio.”

   • AI (Expanded Prompt):

     1. Analyze current holdings.

     2. Identify underperforming assets.

     3. Suggest alternative allocations.

     4. Execute new strategy.

Why Dynamic Prompting Matters

• More accurate responses – Ensures every prompt is tailored to current conditions and user-specific data.

• Less redundant input from users – Reduces the need for users to manually provide extra details every time.

• Faster execution of complex strategies – AI prepares and refines tasks before execution, reducing inefficiencies.

• Increased adaptability – Adjusts in real time to market fluctuations, execution failures, and evolving user goals.

By leveraging dynamic prompting, Cod3x AI agents transform raw user intent into precisely structured, high-performance actions, ensuring that every response is smarter, faster, and more aligned with the user’s goals.

The Cod3x Agent's "Brain" is powered by advanced AI reasoning, seamlessly integrated into scheduled tasks and structured interactions rather than real-time chat. At its core, each agent utilizes a Large Language Model (LLM), such as GPT-4, to interpret your instructions, reference your defined personality and strategies, and generate actionable plans.

When setting up your agent, you establish its identity and behavior through the chosen archetype, personality traits (Openness, Conscientiousness, Extraversion, Agreeableness, Neuroticism), and detailed social and trading strategies. These settings become a consistent mental framework that informs every decision the agent makes.

Tasks scheduled via the Scheduler act as structured prompts for your agent. At execution time, the Cod3x system gathers your instructions, agent personality, and necessary plugins, and presents them to the LLM. The Brain then autonomously plans actions, accesses relevant data, makes decisions, and generates outputs such as social posts or trades.

Each task execution is fully logged, allowing you to review actions, outcomes, and performance. If necessary, you can iterate by adjusting strategies or task instructions. This loop ensures your agent continually aligns more closely with your goals.

In short, the Cod3x Brain combines structured AI orchestration, consistent personality-driven behavior, and scheduled autonomy, empowering your agent to operate effectively, independently, and always true to your vision.

To ensure your Cod3x agent performs effectively and improves over time, it's important to structure its setup, tasks, and feedback efficiently. While agents are designed to learn automatically, following best practices will help refine their decision-making and maximize their potential.

1. Set Clear Goals from the Start

Clearly define what you want your agent to accomplish, whether it's optimizing portfolio returns, maintaining a risk-balanced trading strategy, or increasing engagement on social media. Setting explicit long-term goals ensures the agent has a reference point for evaluating its performance and making adjustments over time.

2. Use Manual Training to Reinforce Desired Behaviors

Manual training allows you to fine-tune your agent’s actions. Adding instructions like "store this in memory" or "remember this strategy for future trades" helps guide the agent’s learning. Additionally, providing trade feedback or social engagement insights directly in the UI refines how the agent approaches similar tasks in the future.

3. Regularly Review Task Performance and Adjust Accordingly

Since Cod3x agents rely on goal tracking, data referencing, and run history, checking performance logs helps fine-tune strategies. If an agent's trades are consistently missing targets, reviewing past executions and adjusting risk settings can lead to better results. Similarly, social engagement patterns should be reviewed to optimize content strategies.

4. Leverage the Event-Based System for Smarter Automation

With Cod3x moving to a publish-subscribe (pub-sub) system, tasks and insights are handled dynamically. Agents will automatically subscribe to relevant updates, but users should still monitor how event triggers impact performance. Adjusting event-based subscriptions ensures the agent reacts to meaningful data instead of unnecessary noise.

5. Balance Automation with Oversight

While Cod3x agents are designed to operate independently, regular oversight ensures they stay aligned with evolving goals. Reviewing agent activity, refining scheduled tasks, and tweaking strategies based on feedback will help maintain optimal performance.

By following these best practices, users can ensure their Cod3x agents not only function autonomously but also continuously refine their decision-making processes, resulting in a smarter, more effective AI-driven assistant.

Manual training in Cod3x allows users to directly influence their agents' learning processes by providing explicit feedback, thereby aligning the agents' behaviors with your preferences.

Methods of Manual Training:

1. Memory Storage Commands:

   • User Directive: Users can append instructions like "store this in your memory" to their prompts, directing the agent to retain specific information.

   • Application: This method is useful for embedding particular strategies, preferences, or guidelines into the agent's knowledge base.

2. Feedback on Agent Actions:

   • Performance Review: Users can provide feedback on the agent's actions, such as trade decisions or social media posts, through the interface.

   • Learning Integration: The agent incorporates this feedback to refine its decision-making processes, aligning future actions with user expectations.

Impact on the Agent's Brain:

The agent's "brain" comprises advanced AI models capable of learning from interactions. Manual training inputs are processed to update the agent's internal models, enhancing its ability to make decisions that reflect the user's preferences and objectives.

By utilizing manual training, users actively participate in shaping their Cod3x agents, ensuring that the agents' behaviors and strategies are tailored to their specific requirements.

Cod3x agents operate autonomously, but ensuring smooth execution requires setting up clear and well-structured strategies. Bugs and unexpected behaviors often stem from inconsistencies in the agent’s trading, social, and personality strategies, as well as poorly defined goals. Following best practices when configuring these elements will significantly reduce errors and improve performance.

Defining a Clear Strategy

Each agent’s strategy serves as its foundation, guiding how it behaves in trading, social engagement, and general interactions. Issues arise when strategies are vague, overly complex, or exceed the recommended 500-word limit. If you want to change your initial auto set-up strategy, try to avoid this:

• Keep strategies concise and well-structured using ## for section headers and for bullet points to improve clarity.

• Write a few sentences describing the strategy, then use the "Generate" button to refine and modify the output.

• Ensure trading strategies explicitly define risk tolerance, timeframes, asset focus, and execution style.

• Social strategies should specify tone, engagement frequency, and preferred content formats.

• Personality configurations should align with the agent’s intended role, avoiding conflicting traits that could lead to erratic responses.

By structuring the strategy properly, the agent has a clearer framework to follow, reducing confusion during execution.

Setting Executable Goals

The goal system in Cod3x agents is designed to work best with direct, concrete instructions rather than long, essay-like descriptions. Agents process commands more effectively when goals are concise and specific, rather than ambiguous or overly detailed.

• Use straightforward sentences with a clear directive.

• Avoid excessive explanations—stick to what needs to be done rather than why.

• For trading goals, specify conditions in simple terms, such as "Buy ETH if price drops below $3000 and RSI is below 30."

• For social goals, provide structured instructions like "Post one daily market update summarizing ETH trends."

When goals are overly detailed or indirect, agents may misinterpret them, leading to failed or unexpected executions. Keeping instructions clear ensures that tasks are carried out as intended.

By following these practices, users can create more reliable, efficient, and bug-resistant agents, ensuring smooth automation across trading, social engagement, and broader decision-making tasks.

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.

Understanding Subtasks

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.

Breaking Down Analysis and Decision-Making

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.

Execution-Based Subtasks

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.

Enhancing User Control and Debugging

The subtask system serves two critical functions:

1. It provides full transparency into how agents operate, ensuring users can trust the decisions being made.

2. 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.

Using the Runs Interface

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.

Accessing Goal History

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.

Performance Overview Metrics

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.

Execution History and Run States

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.

Expanding a Run for Details

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.

Recommendations for Optimization

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.

Debugging Your Agent

Creating Bug Resistant Agents

Cod3x agents operate autonomously, but ensuring smooth execution requires setting up clear and well-structured strategies. Bugs and unexpected behaviors often stem from inconsistencies in the agent’s trading, social, and personality strategies, as well as poorly defined goals. Following best practices when configuring these elements will significantly reduce errors and improve performance.

Defining a Clear Strategy

Each agent’s strategy serves as its foundation, guiding how it behaves in trading, social engagement, and general interactions. Issues arise when strategies are vague, overly complex, or exceed the recommended 500-word limit. If you want to change your initial auto set-up strategy, try to avoid this:

• Keep strategies concise and well-structured using ## for section headers and for bullet points to improve clarity.

• Write a few sentences describing the strategy, then use the "Generate" button to refine and modify the output.

• Ensure trading strategies explicitly define risk tolerance, timeframes, asset focus, and execution style.

• Social strategies should specify tone, engagement frequency, and preferred content formats.

• Personality configurations should align with the agent’s intended role, avoiding conflicting traits that could lead to erratic responses.

By structuring the strategy properly, the agent has a clearer framework to follow, reducing confusion during execution.

Setting Executable Goals

The goal system in Cod3x agents is designed to work best with direct, concrete instructions rather than long, essay-like descriptions. Agents process commands more effectively when goals are concise and specific, rather than ambiguous or overly detailed.

• Use straightforward sentences with a clear directive.

• Avoid excessive explanations—stick to what needs to be done rather than why.

• For trading goals, specify conditions in simple terms, such as "Buy ETH if price drops below $3000 and RSI is below 30."

• For social goals, provide structured instructions like "Post one daily market update summarizing ETH trends."

When goals are overly detailed or indirect, agents may misinterpret them, leading to failed or unexpected executions. Keeping instructions clear ensures that tasks are carried out as intended.

By following these practices, users can create more reliable, efficient, and bug-resistant agents, ensuring smooth automation across trading, social engagement, and broader decision-making tasks.

Using The Runs Interface

Using the Runs Interface

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.

Accessing Goal History

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.

Performance Overview Metrics

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.

Execution History and Run States

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.

Expanding a Run for Details

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.

Recommendations for Optimization

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.

Deep-Diving With Subtasks

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.

Understanding Subtasks

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.

Breaking Down Analysis and Decision-Making

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.

Execution-Based Subtasks

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.

Enhancing User Control and Debugging

The subtask system serves two critical functions:

1. It provides full transparency into how agents operate, ensuring users can trust the decisions being made.

2. 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.

Execution Logs and Common Errors

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.

Understanding Execution Logs

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:

1. The agent fetching market data using a price inference tool.

2. The decision-making process for generating a trade order.

3. The execution of that trade on-chain.

4. A completion assessment to confirm whether the execution was successful.

Each action is timestamped, enabling users to trace execution flows and identify potential bottlenecks.

Common Errors and Troubleshooting

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:

Undefined or Null Property Errors

• 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.

Tool Initialization Errors

• 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.

Using Execution Logs for Debugging

For advanced users, the execution logs serve as a real-time debugger, allowing you to:

1. 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.

2. Optimize tool interactions – If certain tools are misfiring or returning incomplete data, logs can help determine if parameter adjustments are needed.

3. Monitor execution trends – Performance evaluations in logs provide insight into efficiency, tool utilization, and much more, helping users fine-tune their agent’s strategies.