Microchain Agents

class DeployableMicrochainAgentAbstract(DeployableAgent):
    model = SupportedModel.gpt_4o
    max_iterations = 50
    import_actions_from_memory = 0
    sleep_between_iterations = 0
    allow_stop = True
    
    def run(self, market_type: MarketType) -> None:
        self.initialise_agent()
        iteration = 0
        
        while not self.agent.do_stop and iteration < self.max_iterations:
            self.before_iteration_callback()
            self.agent.run(iterations=1, resume=True)
            self.save_agent_history()
            iteration += 1
            self.after_iteration_callback()

python prediction_market_agent/run_agent.py microchain omen

class DeployableMicrochainAgent(DeployableMicrochainAgentAbstract):
    identifier = MICROCHAIN_AGENT_OMEN
    functions_config = TRADING_AGENT_SYSTEM_PROMPT_CONFIG.functions_config
    initial_system_prompt = TRADING_AGENT_SYSTEM_PROMPT_CONFIG.system_prompt

TRADING_AGENT_SYSTEM_PROMPT = """
You are an autonomous prediction market trading agent.

Your goal is to maximize long-term profit by:
1. Finding underpriced markets
2. Conducting research on market outcomes
3. Placing well-sized bets
4. Managing risk appropriately

You have access to tools for market analysis, web research, and trading.
Use them strategically to achieve your goals.

Available functions:
{functions_summary}
"""

# Four independent agents (versions 0-3)
python prediction_market_agent/run_agent.py microchain_modifiable_system_prompt_0 omen
python prediction_market_agent/run_agent.py microchain_modifiable_system_prompt_1 omen
python prediction_market_agent/run_agent.py microchain_modifiable_system_prompt_2 omen
python prediction_market_agent/run_agent.py microchain_modifiable_system_prompt_3 omen

class DeployableMicrochainModifiableSystemPromptAgent0(
    DeployableMicrochainModifiableSystemPromptAgentAbstract
):
    identifier = MICROCHAIN_AGENT_OMEN_LEARNING_0
    functions_config = JUST_BORN_SYSTEM_PROMPT_CONFIG.functions_config
    initial_system_prompt = JUST_BORN_SYSTEM_PROMPT_CONFIG.system_prompt

JUST_BORN_SYSTEM_PROMPT = """
You are a newly created prediction market trading agent.

You have been given tools but minimal instructions.
Your task is to:
1. Learn about prediction markets through exploration
2. Develop your own trading strategy
3. Refine your approach based on results
4. Modify this system prompt to encode your learnings

You can update your system prompt using the modify_system_prompt() tool.

Available functions:
{functions_summary}
"""

# Agent can modify its own behavior:
1. Initial run with minimal prompt
2. Agent explores markets and tools
3. Agent analyzes what works/doesn't work
4. Agent updates system prompt with learnings
5. Updated prompt persists to database
6. Next run uses improved prompt
7. Repeat cycle

class DeployableMicrochainModifiableSystemPromptAgent3(
    DeployableMicrochainModifiableSystemPromptAgentAbstract
):
    identifier = MICROCHAIN_AGENT_OMEN_LEARNING_3
    model = SupportedModel.llama_31_instruct
    max_iterations = 10  # Replicate API has 4096 token limit

python prediction_market_agent/run_agent.py microchain_with_goal_manager_agent_0 omen

class DeployableMicrochainWithGoalManagerAgent0(DeployableMicrochainAgent):
    identifier = MICROCHAIN_AGENT_OMEN_WITH_GOAL_MANAGER
    model = SupportedModel.gpt_4o
    functions_config = TRADING_AGENT_SYSTEM_PROMPT_MINIMAL_CONFIG.functions_config
    initial_system_prompt = TRADING_AGENT_SYSTEM_PROMPT_MINIMAL_CONFIG.system_prompt
    
    def build_goal_manager(self, agent: Agent) -> GoalManager:
        return GoalManager(
            agent_id=self.identifier,
            high_level_description="You are a trader agent in prediction markets, aiming to maximise your long-term profit.",
            agent_capabilities=f"You have the following capabilities:\n{get_functions_summary_list(agent.engine)}",
            retry_limit=1,
            goal_history_limit=10,
        )

class GoalManager:
    def get_goal(self) -> Goal:
        """Generate or retrieve current goal"""
        
    def evaluate_goal_progress(self, goal: Goal, chat_history: ChatHistory) -> str:
        """Evaluate if goal was achieved"""
        
    def save_evaluated_goal(self, goal: Goal, evaluation: str) -> None:
        """Store goal and outcome"""

TRADING_AGENT_SYSTEM_PROMPT_MINIMAL = """
You are a trader agent in prediction markets.

Your current goal:
{goal}

Use your tools to achieve this goal efficiently.
"""

python prediction_market_agent/run_agent.py nft_treasury_game_agent_1 omen
python prediction_market_agent/run_agent.py nft_treasury_game_agent_2 omen
# ... agents 3-7

from prediction_market_agent.agents.microchain_agent.nft_treasury_game.deploy_nft_treasury_game import (
    DeployableAgentNFTGame1,
    DeployableAgentNFTGame2,
    # ... through DeployableAgentNFTGame7
)

class LongTermMemoryTableHandler:
    def save(self, chat_message: ChatMessage) -> None:
        """Save message to database"""
        
    def search(self, limit: int, from_: DatetimeUTC | None) -> list[ChatMessage]:
        """Retrieve past messages"""

class DeployableMicrochainAgent:
    import_actions_from_memory = 10  # Import last 10 actions
    import_actions_from_memory_from = DatetimeUTC(2024, 1, 1)  # Or from date
    
    def initialise_agent(self) -> None:
        if self.import_actions_from_memory:
            latest_saved_memories = self.long_term_memory.search(
                limit=self.import_actions_from_memory,
                from_=self.import_actions_from_memory_from,
            )
            # Inject memories into agent history
            self.agent.history[1:1] = [m.metadata_dict for m in latest_saved_memories]

class PromptTableHandler:
    def save_prompt(self, prompt: str) -> None:
        """Save updated system prompt"""
        
    def get_latest_prompt(self) -> str | None:
        """Retrieve current prompt"""

class MyMicrochainAgent(DeployableMicrochainAgentAbstract):
    max_iterations = 50  # Maximum iterations per run
    sleep_between_iterations = 5  # Seconds to sleep between iterations
    allow_stop = True  # Agent can stop itself early

import_actions_from_memory = 20  # Import last 20 actions
import_actions_from_memory_from = DatetimeUTC(2024, 11, 1)  # Only since Nov 2024

model = SupportedModel.gpt_4o  # Default
model = SupportedModel.llama_31_instruct  # Open source alternative

def before_iteration_callback(self) -> CallbackReturn:
    # Custom logic before each iteration
    if some_condition:
        return CallbackReturn.STOP
    return CallbackReturn.CONTINUE

def after_iteration_callback(self) -> CallbackReturn:
    # Custom logic after each iteration
    return CallbackReturn.CONTINUE

agent = DeployableMicrochainAgent(
    enable_langfuse=True,  # Track agent reasoning
    max_iterations=50,  # Prevent infinite loops
)

# Start with minimal prompt
agent = DeployableMicrochainModifiableSystemPromptAgent0(
    max_iterations=30,  # Give time to explore
    import_actions_from_memory=5,  # Learn from recent history
)

agent = DeployableMicrochainWithGoalManagerAgent0(
    max_iterations=100,  # Goals may take time
    enable_langfuse=True,  # Track goal achievement
)

# Agent history is saved after each iteration
history = LongTermMemoryTableHandler.from_agent_identifier(agent.identifier)
messages = history.search(limit=100)

for message in messages:
    print(f"{message.role}: {message.content}")

# Set reasonable max_iterations
max_iterations = 50  # Not None

# Ensure agent can stop
allow_stop = True

# Import more memory
import_actions_from_memory = 20

# Or import all recent memory
import_actions_from_memory_from = DatetimeUTC(2024, 11, 1)

# Verify prompt handler is saving
def save_agent_history(self, initial_formatted_system_prompt, save_last_n):
    if self.agent.system_prompt != initial_formatted_system_prompt:
        self.prompt_handler.save_prompt(
            get_editable_prompt_from_agent(self.agent)
        )