1. Learning Objectives

By the end of this lesson, you will be able to:

• Understand the concept of agentic AI and the difference between agents and traditional AI systems.

• Design and implement autonomous trading agents using LLMs for reasoning and action.

• Build multi-agent systems for portfolio management, risk assessment, and compliance automation.

• Implement agent orchestration frameworks (e.g., AutoGen, CrewAI, LangChain).

• Understand the challenges of agent evaluation, safety, and alignment in financial contexts.

• Design human-in-the-loop systems for risk oversight and agent monitoring.

2. What is Agentic AI?

2.1 Definition and Core Characteristics

An AI agent is an autonomous entity that uses perception, reasoning, and action to achieve goals in a dynamic environment. Agents can be:

• Reactive: Respond to immediate stimuli (e.g., market orders).

• Deliberative: Plan actions based on internal models (e.g., portfolio rebalancing).

• Hybrid: Combine reactive and deliberative capabilities.

In the context of LLMs, an agent is typically an LLM that has been augmented with tools (APIs, functions, data retrieval) and memory (short-term and long-term). The agent can:

1. Perceive: Observe the environment (market data, news, social media).

2. Reason: Analyze the situation, plan actions, and make decisions.

3. Act: Execute actions (place trades, generate reports, send alerts).

2.2 Why Agents in Finance?

• Automation: Reduce manual intervention in routine tasks (e.g., trade execution, report generation).

• Complexity: Handle complex, multi-step workflows (e.g., researching, analyzing, and executing a trade).

• Adaptability: Adapt to changing market conditions and new information.

• Scalability: Operate 24/7 and handle multiple tasks simultaneously.

3. Single-Agent Systems

3.1 Agent Architecture

A typical LLM-based agent consists of the following components:

1. LLM Core: The “brain” of the agent (e.g., GPT-4, LLaMA-2). It processes the input, reasons, and generates actions.

2. Tool Access: APIs and functions the agent can call (e.g., market data API, trading API, news API).

3. Memory: Short-term memory (the context window) and long-term memory (vector database, knowledge graph).

4. Planning Module: The LLM’s ability to break down a goal into a sequence of steps (e.g., using chain-of-thought or tree-of-thought).

3.2 Designing a Trading Agent

Goal: The agent’s goal is to maximize the Sharpe ratio of a trading portfolio.

Tools:

• get_price(ticker, date) -> price

• get_historical_data(ticker, start, end) -> DataFrame

• get_news(ticker, date) -> list_of_articles

• execute_trade(ticker, quantity, side) -> confirmation

• calculate_portfolio_value() -> value

Memory:

• Short-term: The current market context, recent trades, and news.

• Long-term: Historical trading performance, learned strategies, and market patterns.

Agent Loop:

while True:
    1. Observe the market (prices, news, portfolio).
    2. Analyze the situation (technical indicators, sentiment, risk).
    3. Reason about the next action (using the LLM).
    4. Plan a sequence of actions (if needed).
    5. Execute the action(s).
    6. Evaluate the outcome.

3.3 Prompt for a Trading Agent

You are an autonomous trading agent. Your goal is to maximize the Sharpe ratio of the portfolio.

Current portfolio: {portfolio_summary}
Market data: {market_data}
Recent news: {news}

Available actions:
- get_price(ticker)
- get_news(ticker)
- execute_trade(ticker, quantity, side)
- wait(time)

Provide a step-by-step plan for the next actions.

Let's think step by step:
1. Analyze current positions and market conditions.
2. Identify opportunities or risks.
3. Determine the optimal action.
4. Execute the action.

Plan:

3.4 The ReAct Pattern

ReAct (Reasoning + Acting) is a popular pattern for LLM agents. It alternates between reasoning (thinking) and acting (executing tools). This allows the agent to gather information and adjust its plan as new data arrives.

ReAct loop:

While not done:
    Thought: [The agent thinks about what to do]
    Action: [The agent executes a tool]
    Observation: [The agent observes the result]

Example:

Thought: I need to check the current price of AAPL.
Action: get_price("AAPL")
Observation: The price is $175.50.
Thought: The price has increased by 2% today. I should analyze the news.
Action: get_news("AAPL")
Observation: [News: "Apple announces new product line"]
Thought: This is a positive catalyst. I might consider increasing the position.
Action: execute_trade("AAPL", 100, "buy")
Observation: Trade executed.
Thought: I'll monitor the price and adjust if needed.

4. Multi-Agent Systems

Multi-agent systems consist of multiple agents that collaborate to achieve a common goal or solve a complex problem. Each agent can have a specific role and expertise.

4.1 Why Multi-Agent Systems in Finance?

• Role specialization: Different agents can specialize in different tasks (e.g., data collection, research, trading, risk management).

• Parallelization: Agents can work concurrently, reducing latency.

• Robustness: If one agent fails or is biased, others can compensate.

• Explainability: The division of labor makes the system more transparent.

4.2 Agent Roles in Financial Multi-Agent Systems

4.3 Multi-Agent Architecture

Orchestrator pattern:

A central orchestrator agent coordinates the other agents.

1. The orchestrator receives a user request (e.g., "Optimize the portfolio for the next quarter").
2. It delegates tasks:
   a. Data Agent: Collect relevant data.
   b. Research Agent: Analyze the data.
   c. Sentiment Agent: Analyze sentiment.
   d. Portfolio Agent: Determine the optimal allocation.
3. It aggregates the results and presents the final output.

Autonomous collaboration:

Agents communicate and collaborate without a central coordinator.

1. The Data Agent posts data to a shared memory (e.g., a vector database).
2. The Research Agent reads the data and posts its insights.
3. The Sentiment Agent reads the data and posts its sentiment scores.
4. The Portfolio Agent reads the insights and sentiment to determine the allocation.
5. The Execution Agent executes the trades.

4.4 Multi-Agent Frameworks

Example: Using AutoGen for Financial Research

from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

research_agent = AssistantAgent(
    name="ResearchAgent",
    system_message="You are a financial research analyst. Provide insights on companies and markets."
)

trading_agent = AssistantAgent(
    name="TradingAgent",
    system_message="You are a trader. Create trading strategies based on research insights."
)

risk_agent = AssistantAgent(
    name="RiskAgent",
    system_message="You are a risk manager. Evaluate and mitigate risks."
)

user_proxy = UserProxyAgent(
    name="UserProxy",
    human_input_mode="NEVER",
    code_execution_config={"work_dir": "coding"}
)

group_chat = GroupChat(
    agents=[research_agent, trading_agent, risk_agent, user_proxy],
    messages=[],
    max_round=10
)
manager = GroupChatManager(groupchat=group_chat)

user_proxy.initiate_chat(
    manager,
    message="Analyze the impact of recent Fed rate hikes on bank stocks and suggest a portfolio strategy."
)

4.5 Multi-Agent Collaboration Patterns

Debate pattern for investment decisions:

1. Bull Agent: Presents the bullish case.
2. Bear Agent: Presents the bearish case.
3. Neutral Agent: Evaluates both arguments.
4. Decision Agent: Makes the final decision.

5. Human-in-the-Loop Systems

5.1 Why Human-in-the-Loop?

• Risk: Autonomous agents can make costly mistakes.

• Regulation: Some decisions require human oversight (e.g., large trades, SAR filings).

• Trust: Stakeholders need confidence in the system.

5.2 Design Patterns

Example: Human approval for trades:

Agent: "I propose to buy 100 shares of AAPL at $175.00."
Human: "Approved" or "Rejected" (with reason).

5.3 Implementing Human-in-the-Loop with AutoGen

AutoGen supports human input at various stages:

user_proxy = UserProxyAgent(
    name="UserProxy",
    human_input_mode="ALWAYS",  # Human must approve each action.
    code_execution_config={"work_dir": "coding"}
)

6. Evaluating Agentic Systems

6.1 Key Metrics

6.2 Sandbox Testing

Before deploying an agent in a live market, test it in a sandbox environment:

• Historical simulation: Run the agent on historical data.

• Paper trading: Run the agent in a simulated environment with real-time data (but no actual money).

• Adversarial testing: Test the agent with challenging scenarios (e.g., market crashes, data outages).

6.3 Monitoring and Alerts

During deployment, continuously monitor:

• Performance: Track profitability, Sharpe ratio, and other metrics.

• Behavior: Log all actions and reasoning.

• Risk: Monitor VaR, drawdown, and exposure.

• Compliance: Check for regulatory violations.

7. Challenges and Mitigations

8. Summary for the AI Practitioner

• Agentic AI enables autonomous, goal-driven automation in finance.

• Single-agent systems use an LLM with tools, memory, and planning.

• Multi-agent systems enable role specialization, parallelization, and robustness.

• ReAct is a key pattern for LLM agents, alternating reasoning and acting.

• Human-in-the-loop systems are essential for risk management and regulatory compliance.

• Evaluation must include task completion, accuracy, safety, and robustness.

• Challenges include hallucination, unintended actions, and regulatory compliance.

This completes Lessons 9.3 and 9.4. Would you like to continue with Lessons 9.5 and 9.6?