Agents

This page explains the concept of Agents within the JuliaOS ecosystem.

Agent System

Agent Creation and Management: Comprehensive agent creation, management, and specialization with support for different agent types.
Agent Types: Support for various agent types including trading, arbitrage, liquidity, monitoring, and data agents.
Agent Configuration: Flexible agent configuration with customizable parameters and behaviors.
Agent Storage: Persistent storage of agent configurations and states with both local and decentralized options.
Agent Communication: Inter-agent communication for collaborative problem-solving and information sharing.
Agent Monitoring: Real-time monitoring of agent activities and performance metrics.
Agent Deployment: Easy deployment of agents across different environments and blockchain networks.
Agent Specialization: Specialized agents for specific tasks and domains with optimized performance.

What is an Agent?

In JuliaOS, an Agent is an autonomous software entity designed to perform specific tasks, often related to blockchain interactions, data analysis, or trading strategies. Think of them as specialized workers that can operate independently or as part of a larger group (a Swarm).

Key Characteristics:

Autonomy: Agents can operate without direct human intervention once started, based on their programming and configuration.
State: They maintain internal information, including their configuration, working memory (observations, decisions), and current operational status (e.g., idle, active, error).
Skills: Agents possess skills – specific functions or capabilities they can execute (e.g., market_analysis, execute_trade, status_report). Skills define what an agent can do.
Configuration: Each agent is set up with parameters defining its type (e.g., Trading, Arbitrage, Monitoring), name, capabilities, network settings, and parameters specific to its logic or skills (e.g., risk tolerance, target assets).
Lifecycle: Agents have a defined lifecycle: they can be created, started, stopped, updated, and deleted.
Communication: Agents have the potential to communicate with each other or with swarms via messages, allowing for coordination.
Swarm Membership: Agents can optionally belong to a Swarm, contributing to a collective goal or benefiting from swarm intelligence.

How Agents Work (Conceptual)

Initialization: When an agent is created (via CLI or API), its configuration is stored (usually in the SQLite database via Storage.jl), and its initial runtime state (AgentState) is set up in the Julia backend's memory (AgentSystem.jl). Default skills based on its type might be registered.
Activation: When started, a background task (async loop) is typically launched for the agent in the Julia backend (run_agent_loop!).
Execution Loop: While active, the agent periodically (based on update_interval):
- Processes incoming messages (if any).
- Executes scheduled skills (e.g., perform market analysis every hour).
- Updates its internal memory and metrics.
- Makes decisions based on its logic, skills, and current state.
- Potentially interacts with external systems (blockchain via Blockchain.jl, DEXes via DEX.jl, APIs) as part of skill execution.
Deactivation: When stopped, the background task is terminated, and the agent becomes inactive.

Common Agent Types

JuliaOS includes several pre-defined agent types, each with specific capabilities and use cases:

Trading Agents

Trading agents are specialized in trading and financial operations. They can:

Analyze market data and trends
Execute trades based on strategies
Manage portfolios and risk
Implement various trading strategies (momentum, mean reversion, etc.)
Monitor market conditions and react accordingly

Example of creating a trading agent:

# Julia
using JuliaOS.TradingAgent

trading_config = TradingAgentConfig(
    "MyTradingAgent",
    chains=["ethereum", "polygon"],
    risk_level="medium",
    max_position_size=1000.0,
    take_profit=0.05,
    stop_loss=0.03,
    trading_pairs=["ETH/USDC", "MATIC/USDC"],
    strategies=["momentum", "mean_reversion"]
)

trading_agent = createTradingAgent(trading_config)

# Python
from juliaos import JuliaOS
from juliaos.agents import AgentType

async def create_trading_agent():
    juliaos_client = JuliaOS(host="localhost", port=8052)
    await juliaos_client.connect()

    trading_agent = await juliaos_client.agents.create_agent(
        name="MyTradingAgent",
        agent_type=AgentType.TRADING,
        config={
            "parameters": {
                "risk_tolerance": 0.5,
                "max_position_size": 1000.0,
                "take_profit": 0.05,
                "stop_loss": 0.03,
                "trading_pairs": ["ETH/USDC", "BTC/USDC"],
                "strategies": ["momentum", "mean_reversion"]
            }
        }
    )

    return trading_agent

Research Agents

Research agents are specialized in conducting research and analysis. They can:

Collect and analyze data from various sources
Generate reports and insights
Identify trends and patterns
Make predictions based on data
Provide recommendations

Example of creating a research agent:

# Julia
using JuliaOS.ResearchAgent

research_config = ResearchAgentConfig(
    "MyResearchAgent",
    research_areas=["market", "technology", "sentiment"],
    data_sources=["web", "api", "database"],
    analysis_methods=["statistical", "nlp", "trend"],
    output_formats=["text", "json", "chart"]
)

research_agent = createResearchAgent(research_config)

# Python
from juliaos import JuliaOS
from juliaos.agents import AgentType

async def create_research_agent():
    juliaos_client = JuliaOS(host="localhost", port=8052)
    await juliaos_client.connect()

    research_agent = await juliaos_client.agents.create_agent(
        name="MyResearchAgent",
        agent_type=AgentType.RESEARCH,
        config={
            "parameters": {
                "research_areas": ["market", "technology", "sentiment"],
                "data_sources": ["web", "api", "database"],
                "analysis_methods": ["statistical", "nlp", "trend"],
                "output_formats": ["text", "json", "chart"]
            }
        }
    )

    return research_agent

Dev Agents

Dev agents are specialized in software development. They can:

Write code in various languages
Review and debug code
Test code and identify issues
Optimize code for performance
Implement specific frameworks and libraries

Example of creating a dev agent:

# Julia
using JuliaOS.DevAgent

dev_config = DevAgentConfig(
    "MyDevAgent",
    languages=["python", "javascript", "julia"],
    frameworks=["react", "tensorflow", "flask"],
    specialties=["web", "ai", "blockchain"],
    code_style="clean"
)

dev_agent = createDevAgent(dev_config)

# Python
from juliaos import JuliaOS
from juliaos.agents import AgentType

async def create_dev_agent():
    juliaos_client = JuliaOS(host="localhost", port=8052)
    await juliaos_client.connect()

    dev_agent = await juliaos_client.agents.create_agent(
        name="MyDevAgent",
        agent_type=AgentType.DEV,
        config={
            "parameters": {
                "languages": ["python", "javascript", "julia"],
                "frameworks": ["react", "tensorflow", "flask"],
                "specialties": ["web", "ai", "blockchain"],
                "code_style": "clean"
            }
        }
    )

    return dev_agent

Arbitrage Agents

Arbitrage agents are specialized in finding and executing arbitrage opportunities. They can:

Monitor prices across different exchanges or chains
Identify price discrepancies
Execute trades to exploit arbitrage opportunities
Manage risk and optimize execution
Track performance and adjust strategies

Monitoring Agents

Monitoring agents are specialized in tracking systems, data, and events. They can:

Monitor blockchain networks and transactions
Track market conditions and price movements
Detect anomalies and trigger alerts
Collect and analyze data
Generate reports and notifications

Custom Agents

You can create custom agent types by extending the base agent functionality and implementing custom logic and capabilities.

Interacting with Agents

CLI: The User Guide: CLI section shows how to manage agents via the interactive command line.
Programmatic (JS/TS): The @juliaos/framework package provides AgentManager for interacting with agents. See Node.js API.
Programmatic (Python): The juliaos Python package provides the JuliaOS client and Agent class. See Python API.