From Rule-Based to Learning Agents

Computational Analysis of Social Complexity

Fall 2025, Spencer Lyon

Prerequisites

• Agent-Based Models (Weeks 6-7)
• Basic Julia programming
• Schelling segregation model

Outcomes

• Distinguish between rule-based agents (traditional ABMs) and learning agents
• Understand how LLMs function as general-purpose reasoning engines
• Implement basic LLM API calls in Julia
• Compare emergent behaviors of AI agents vs programmed agents

References

• Attention Is All You Need - The transformer paper
• Language Models are Few-Shot Learners - GPT-3 paper
• Anthropic Claude Documentation
• OpenAI API Documentation
• AI Agents Survey Paper

A Tale of Two Agents¶

• We’ve spent two weeks studying agent-based models
• Remember the Schelling segregation model?
  • Agents with simple rules: “move if less than N neighbors are like me”
  • Environment: 25x25 grid
  • Result: stark segregation patterns emerge from mild preferences
• Those were rule-based agents - they follow explicit, programmed instructions

Now let me show you something different.

Suppose I asked you to write an agent that could:

• Analyze a news article and summarize it
• Answer questions about complex topics it’s never seen before
• Generate creative stories in the style of different authors
• Write code to solve novel problems
• Engage in strategic reasoning about social situations

How would you program those rules?

You probably can’t - at least not easily. The rule set would be impossibly complex.

This is where learning agents come in.

The Fundamental Shift¶

Over the past few years, we’ve witnessed a fundamental shift in how we build intelligent systems:

Rule-Based Approach (Traditional ABMs):

• Developer writes explicit rules
• Agent follows those rules deterministically (or with simple randomness)
• Behavior is predictable from the code
• Example: if unhappy then move to random location

Learning Approach (Modern AI):

• Developer provides training data and objectives
• System learns patterns and relationships
• Behavior emerges from learned representations
• Example: “Here are 10 trillion words from the internet - learn to predict what comes next”

The second approach has given us Large Language Models (LLMs) - and they’re remarkably capable.

Connecting to What We Know¶

Before we dive into AI agents, let’s think about what made our ABMs interesting:

In the Schelling Model:

1. Simple agent logic (check neighbors, decide to move)
2. Local information only (can’t see whole grid)
3. Emergent behavior (segregation without a segregationist)
4. Aggregate outcomes differ from individual intentions

In the Money Model:

1. Even simpler logic (give $1 to random agent)
2. No intelligence at all, just random exchanges
3. Power law wealth distribution emerges
4. Inequality arises from equality plus randomness

These models taught us that complexity can emerge from simplicity.

Now consider this: what if we could build agents that aren’t simple?

What if individual agents could:

• Reason about their situation
• Learn from experience
• Communicate in natural language
• Adapt their strategies
• Form and revise beliefs

What kinds of collective behaviors might emerge then?

This is the frontier we’re exploring in this module: Agentic AI Systems.

Understanding Large Language Models¶

What is an LLM?¶

A Large Language Model is a neural network trained to predict the next word (or “token”) in a sequence.

That’s it. Really.

But this simple objective, when applied at massive scale, produces something remarkable: a general-purpose reasoning engine.

The Training Process:

1. Collect enormous amounts of text (books, websites, code, papers, conversations)
2. For each sequence, hide the next word and ask the model to predict it
3. Adjust the model’s parameters (billions of them) to improve predictions
4. Repeat trillions of times

What the Model Learns:

• Grammar and syntax (obvious)
• Facts about the world (it saw them in training data)
• Reasoning patterns (it saw examples of reasoning)
• Causal relationships (they’re implicit in language)
• Social norms and conventions (they’re encoded in how people write)
• Task structures (it saw many examples of questions and answers)

From Next-Word Prediction to Intelligence¶

You might think: “How does predicting the next word lead to intelligence?”

Consider this sequence:

“The doctor told the patient that she would need to come back next week. The patient thanked...”

To predict the next word, the model needs to:

• Track that “she” refers to “the patient”
• Understand doctor-patient relationships
• Know social conventions about gratitude
• Predict “her” (the doctor) is the likely continuation

Or this one:

“If all mammals have hearts, and whales are mammals, then whales...”

To complete this, the model must:

• Recognize a logical argument structure
• Apply deductive reasoning
• Predict “have hearts” or similar

The key insight: To predict text well, you need to model the world.

Text is the trace of human thought, and to predict it accurately, you need to simulate the thinking that produced it.

Transformer Architecture (High-Level Intuition)¶

We won’t dive deep into the math, but here’s the essential idea:

The Challenge: When predicting the next word, which previous words matter?

In “The doctor told the patient that she would need to come back”, the word “doctor” is relevant for predicting what comes after “the patient thanked”.

The Solution: Attention Mechanism

The transformer architecture uses “attention” to let each word look at all previous words and decide which ones are relevant:

"The patient thanked" <-- looks back at entire sequence
                       <-- pays attention to "doctor" (high weight)
                       <-- pays less attention to "told" (medium weight)
                       <-- ignores "the" (low weight)

This attention mechanism is:

• Learned, not programmed (the model figures out what to attend to)
• Parallel (can process all words simultaneously)
• Multi-headed (multiple attention patterns can operate in parallel)
• Stackable (many layers of attention build complex representations)

Network Analogy:

If you squint, attention looks like a weighted graph where:

• Nodes are words/tokens
• Edges are attention weights
• Information flows along high-weight edges

The model learns to construct this graph dynamically based on the input!

Scale is All You Need (Almost)¶

A remarkable empirical finding: model capabilities scale predictably with:

1. Model size (number of parameters)
2. Data size (amount of training text)
3. Compute (training time × hardware)

Scaling Laws show that doubling compute roughly gives consistent improvements.

Modern LLMs (as of 2025):

• GPT-5: ~2+ trillion parameters (estimated)
• Claude Sonnet 4.5: ~500 billion parameters (estimated)
• Claude Haiku 4.5: ~100 billion parameters (estimated)
• Llama 3: 70 billion parameters (open source)

For comparison:

• Human brain: ~86 billion neurons, ~100 trillion synapses
• Each parameter is roughly analogous to a synaptic weight

We’re now at or exceeding biological-scale systems in parameter count.

Prompting as Programming¶

A New Interface for Computation¶

With traditional programming:

• You write explicit instructions in a formal language (Julia, Python, etc.)
• The computer executes them precisely
• You get exactly what you specified (bugs included)

With LLMs:

• You write instructions in natural language
• The model interprets your intent
• You get (hopefully) what you meant

This is prompting - the art and science of instructing LLMs.

Anatomy of a Prompt¶

A good prompt typically includes:

1. Role/Context: Who should the model be?

   • “You are an expert economist...”
   • “You are a helpful teaching assistant...”

2. Task: What should it do?

   • “Analyze the following dataset...”
   • “Summarize this paper in 3 bullet points...”

3. Constraints: How should it do it?

   • “Use only information from the provided text”
   • “Respond in JSON format”
   • “Keep your answer under 100 words”

4. Examples (optional): Show, don’t just tell

   • Few-shot learning: provide input-output examples
   • The model learns the pattern and applies it

5. Output Format: Structure the response

   • “Provide your answer as a numbered list”
   • “Format your response as: Analysis: ... Conclusion: ...”

In-Context Learning¶

One of the most striking capabilities of LLMs is in-context learning:

You can teach the model a new task just by showing it examples in the prompt - no retraining needed!

Example:

Translate English to Pig Latin:

English: hello
Pig Latin: ellohay

English: world  
Pig Latin: orldway

English: agent
Pig Latin:

The model will likely output: agentyay or agentay

It learned the pattern from just two examples!

This is impossible with traditional rule-based agents.

Hands-On: Your First AI Agent¶

Setting Up API Access¶

To use LLMs, we need to call their APIs. The two major providers are:

1. Anthropic - We’ll use their Claude models:

   • Claude Haiku 4.5 (default) - Fast, cost-effective, great for real-time tasks
   • Claude Sonnet 4.5 - Most intelligent, best for complex reasoning and coding
   • Claude Opus 4 - Premium model with extended context (200K tokens)

2. OpenAI - We’ll demonstrate their GPT models using the Responses API:

   • GPT-5 - Flagship model with advanced reasoning
   • GPT-5-mini - Cost-effective, 5x cheaper than GPT-5
   • o3 and o3-mini - Specialized reasoning models

   Note: We use OpenAI’s modern Responses API (/v1/responses) which provides a cleaner interface with separate instructions and input parameters. This is recommended for new projects. See the Responses API Quickstart for more details.

Both require API keys. Send me a message on webcourses and I’ll venmo you $10 to get started

• OpenAI: https://platform.openai.com/signup
• Anthropic: https://console.anthropic.com/

Important: Never commit API keys to git! Use environment variables.

We’ll use the HTTP.jl package to make API calls (it’s already in our Project.toml).

Getting API Keys¶

Cross-Platform Approach: Using .env Files

The best practice is to store your API keys in a .env file that you never commit to git.

1. Create a .env file in your project root (same directory as your notebook):

# .env file
ANTHROPIC_API_KEY=your-anthropic-key-here
OPENAI_API_KEY=your-openai-key-here

2. Add .env to your .gitignore to keep keys secure:

# Add this line to .gitignore
.env

3. Install DotEnv.jl to load environment variables from the .env file:

using Pkg
Pkg.add("DotEnv")

This approach works on Windows, macOS, and Linux without needing to set system environment variables!

Alternative: System Environment Variables (if you prefer)

You can also set environment variables at the system level:

• macOS/Linux: Add to ~/.bashrc or ~/.zshrc:

  export ANTHROPIC_API_KEY="your-key-here"
  export OPENAI_API_KEY="your-key-here"

• Windows (PowerShell):

  $env:ANTHROPIC_API_KEY="your-key-here"
  $env:OPENAI_API_KEY="your-key-here"

• Windows (Command Prompt):

  set ANTHROPIC_API_KEY=your-key-here
  set OPENAI_API_KEY=your-key-here

For this lecture, we’ll use the .env file approach since it’s cross-platform and project-specific.

Making Our First API Call¶

Let’s create a simple function to call Claude’s API:

Check the official documentation for the exact current model names:

• Anthropic: https://docs.anthropic.com/en/docs/models-overview
• OpenAI: https://platform.openai.com/docs/models

Testing Our AI Agent¶

Let’s start simple and ask Claude to explain something:

Comparing Rule-Based and AI Agents¶

Now let’s do something interesting - ask Claude to role-play as both types of agents:

Structured Output: Using AI Agents for Data Analysis¶

One powerful pattern: use LLMs to generate structured data that we can analyze computationally.

Let’s ask Claude to generate synthetic agent data:

Now we have structured data generated by an AI that we can analyze with traditional methods!

This pattern - LLM generation + computational analysis - is extremely powerful.

We can combine the flexibility of natural language with the rigor of computation.

Alternative: Using OpenAI’s Responses API¶

For completeness, here’s how to call OpenAI’s GPT models using their modern Responses API.

Note: OpenAI introduced the Responses API (/v1/responses) as the recommended interface for new projects. It provides a cleaner structure than the older Chat Completions API, with separate instructions for system-level guidance and input for user queries.

Emergent Capabilities of AI Agents¶

From Scale to Surprise¶

Remember how emergence worked in our ABMs?

• Simple local rules
• Complex global patterns
• Outcomes not explicitly programmed

LLMs exhibit a similar phenomenon, but at the model level:

Training Objective: Predict the next word

Emergent Capabilities (things we didn’t explicitly train for):

• Multi-step reasoning
• Code generation and debugging
• Translation between languages
• Mathematical problem solving
• Theory of mind (reasoning about others’ beliefs)
• Tool use
• Planning and strategy

These capabilities often appear suddenly at certain scale thresholds - we call them emergent abilities.

Chain-of-Thought Reasoning¶

One of the most important emergent capabilities is chain-of-thought (CoT) reasoning.

If you ask an LLM to “think step by step”, it performs dramatically better on complex tasks.

Let’s demonstrate:

The second version should be more reliable because we asked the model to show its reasoning.

Why does this work?

The model generates reasoning steps as text, and each step becomes part of the context for the next step.

It’s essentially using its own output as a working memory!

This is analogous to how humans often solve problems by writing things down.

Tool Use: Extending Agent Capabilities¶

Modern LLMs can learn to use external tools:

• Calculators (for precise math)
• Search engines (for current information)
• Code interpreters (for computation)
• Database queries (for data access)
• APIs (for external services)

This is called function calling or tool use.

The pattern:

1. Tell the model what tools are available (in the prompt)
2. Model decides which tool to use
3. Model outputs a structured request (e.g., JSON)
4. Your code executes the tool
5. Return results to the model
6. Model incorporates results and continues

Here’s a simple example:

The model should have identified the correct function call. Let’s execute it:

This simple pattern - prompt → tool identification → execution → interpretation - is the foundation of agentic AI.

We’ll explore this much more deeply in later lectures.

Limitations and Considerations¶

What LLMs Can’t Do (Well)¶

Despite their impressive capabilities, LLMs have important limitations:

1. Precise Arithmetic

• They approximate calculations, don’t compute them
• Solution: Use tools (code execution, calculators)

2. Current Information

• Training data has a cutoff date
• They don’t know recent events
• Solution: Retrieval Augmented Generation (RAG) - next lecture!

3. Consistency Across Calls

• Same prompt can give different answers (they’re stochastic)
• Solution: Use temperature=0 for determinism, or run multiple times and aggregate

4. Following Complex Constraints

• May violate constraints you specify in prompts
• Solution: Validate outputs programmatically

5. Long-Term Memory

• Context window is finite (though growing - now 200K+ tokens)
• Can’t remember everything from earlier in long conversations
• Solution: External memory systems

6. True Understanding

• Philosophical debate: do they “understand” or just pattern-match?
• Practically: they can fail in surprising ways
• Solution: Don’t anthropomorphize, verify critical outputs

Comparing Agent Paradigms¶

Let’s synthesize what we’ve learned:

The key insight: These aren’t competing approaches - they’re complementary!

The most powerful systems combine both:

• LLMs for reasoning, planning, and natural language
• Traditional code for precise computation, data storage, and execution

This hybrid approach is what we’ll explore in the rest of this module.

Connecting to Complex Systems¶

Emergence at Multiple Scales¶

Throughout this course, we’ve studied emergence:

Networks:

• Local: Individual connections
• Global: Small-world structure, clustering

Game Theory:

• Local: Individual strategy choices
• Global: Nash equilibria, social welfare

ABMs:

• Local: Simple agent rules
• Global: Segregation, wealth inequality

LLMs Add a New Dimension:

• Training: Next-word prediction objective
• Emergent: Reasoning, tool use, theory of mind

But here’s what’s really interesting for our course:

What happens when we build multi-agent systems with AI agents?

If simple agents (Schelling model) produce complex outcomes...

What do complex agents produce?

Preview: Agentic AI Systems¶

In the coming lectures, we’ll explore:

Lecture A1.02: RAG and Knowledge Augmentation

• How to give agents access to external knowledge
• Building agents that can retrieve and reason over documents
• Connection to information networks

Lecture A1.03: Multi-Agent Conversations

• AI agents communicating with each other
• Emergent coordination and conflict
• Connection to game theory and strategic interaction

Why This Matters¶

AI agents aren’t just a cool technology - they’re becoming a fundamental part of social complexity:

Economic Systems:

• AI trading agents in financial markets
• Algorithmic pricing and competition
• Automated negotiation

Social Systems:

• AI content creators and curators
• Chatbots as social actors
• Synthetic data and simulation

Scientific Systems:

• AI research assistants
• Automated hypothesis generation
• Tool-augmented discovery

Understanding how these systems work, and how to build them, is increasingly essential for computational social science.

Exercises¶

Exercise 1: Prompt Engineering Fundamentals¶

Part A: Compare prompting styles

Write three different prompts that ask an LLM to explain the Schelling model:

1. Minimal prompt (one sentence)
2. Structured prompt (with role, task, and constraints)
3. Few-shot prompt (with examples of explanations)

Call the API with each prompt and compare the responses. Which works best? Why?

Part B: Constraint following

Design prompts to get an LLM to:

1. Respond in exactly 50 words (±5 words)
2. Respond only with valid JSON
3. Respond as a numbered list with exactly 3 items

Test each prompt. Do the constraints hold? What happens when they fail? Do different models have more consistent results?

Exercise 2: Agent Comparison - Schelling Reimagined¶

Scenario: We want to model neighborhood preferences, but with more nuanced agents.

Part A: Traditional ABM approach

Write pseudocode for a rule-based agent that:

• Has attributes: location, income, family_size, preferences
• Decides whether to move based on:
  • Neighborhood similarity
  • Housing costs
  • School quality

Part B: AI agent approach

Create a prompt that asks an LLM to role-play as a household deciding whether to move.

Give it:

• Current neighborhood statistics
• Alternative neighborhood statistics
• Household characteristics

Ask it to reason about the decision and output a choice + explanation.

Part C: Comparison

Run the AI agent on 5 different scenarios. Analyze:

• Does it consider factors you didn’t explicitly mention?
• Is it consistent across similar scenarios?
• How does its reasoning differ from rule-based logic?

Exercise 3: Chain-of-Thought for Network Analysis¶

Task: Use an LLM with chain-of-thought reasoning to analyze network structure.

Setup: Define a small network in text:

Nodes: A, B, C, D, E
Edges: A-B, B-C, C-D, D-E, E-A, A-C

Questions to ask the LLM (using CoT prompting):

1. What is the diameter of this network?
2. Which node has the highest degree centrality?
3. Are there any triangles (3-cycles)?
4. If we remove edge A-C, does the network remain connected?

Requirements:

• Use “let’s think step by step” prompting
• Verify the LLM’s answers by computing them yourself in Julia
• Document where the LLM is correct vs. incorrect

Extension: Try with a larger network (8-10 nodes). Does accuracy degrade?

Exercise 4: Structured Data Generation¶

Objective: Use an LLM to generate synthetic agent data for an ABM simulation.

Task: Create a prompt that generates data for 20 agents in a “social media network” simulation.

Each agent needs:

• id (integer 1-20)
• personality (one of: influencer, lurker, engager, contrarian)
• posting_frequency (float 0.0-1.0, posts per day)
• topics (array of 1-3 topics from: politics, sports, tech, entertainment, science)
• follower_count (integer, should correlate somewhat with personality)

Requirements:

1. Get the LLM to output valid JSON
2. Parse the JSON into a Julia DataFrame
3. Validate the data (check types, ranges, correlations)
4. Visualize the distribution of personalities and topics

Bonus: Ask the LLM to also generate a “friendship network” as an edge list - who follows whom?

Reflection:

• What advantages does LLM generation have over random generation?
• What disadvantages or risks?

Exercise 5: Tool Use - Network Statistics Calculator¶

Objective: Build a simple agent that uses Julia functions as tools.

Part A: Define tools

Create Julia functions for:

calculate_clustering_coefficient(edges, node)
find_shortest_path(edges, source, target)
calculate_betweenness_centrality(edges, node)

You can use simple implementations or leverage Graphs.jl.

Part B: Create tool-use prompt

Write a prompt that:

1. Describes what each function does (the “tool documentation”)
2. Gives the agent a network analysis question
3. Asks it to identify which tool(s) to use and with what arguments

Part C: Execute and iterate

Create a loop that:

1. Sends prompt to LLM
2. Parses LLM’s tool call request
3. Executes the tool in Julia
4. Returns result to LLM
5. Gets final answer from LLM

Test cases:

• “Which node is most central in this network?” (needs betweenness)
• “How clustered is node A?” (needs clustering coefficient)
• “What’s the shortest path from B to E?” (needs shortest path)

Challenge: Can the agent chain multiple tool calls? (“Find the shortest path from A to C, then calculate the clustering coefficient of each node along that path”)

Exercise 6: Package Organization - Moving API Functions to CAP6318¶

Objective: Practice good code organization by moving reusable functions to your course package.

Throughout this course, you’ve been building a CAP6318 package to organize your code. Now it’s time to add AI agent capabilities to it!

Part A: Create an AI module in your package

In your CAP6318 package directory, create a new file src/AI.jl with the following structure:

module AI

using HTTP
using JSON3

# Export the functions so they can be used outside the module
export call_claude, call_gpt

# Include your call_claude and call_gpt functions here
# (copy from the lecture, but consider adding improvements!)

end  # module

Part B: Integrate into your package

1. Add using DotEnv to your CAP6318 package’s Project.toml dependencies
2. In your main src/CAP6318.jl file, add:

   include("AI.jl")
   using .AI

3. Re-export the AI functions:

   export call_claude, call_gpt

Part C: Test your package

Back in this notebook (or a new one), test that your package works:

using CAP6318

# Test with a simple prompt
response = call_claude("What is computational social science? Answer in 2 sentences.")
println(response)

Part D: Enhancements (Optional)

Consider adding these improvements to your AI module:

1. Error Handling: Wrap API calls in try-catch blocks with informative error messages
2. Response Caching: Store responses in a dictionary to avoid repeated API calls with the same prompt
3. Token Counting: Add a function to estimate token usage before making calls
4. Logging: Track all API calls (prompts, responses, models used) to a file
5. Rate Limiting: Add a small delay between calls to avoid hitting rate limits
6. Multiple Providers: Create a unified call_llm() function that works with both Anthropic and OpenAI

Example Enhanced Function:

function call_claude(prompt; model="claude-haiku-4-5", max_tokens=1024, verbose=false)
    if verbose
        println("Calling $model with prompt of length $(length(prompt)) characters...")
    end
    
    try
        # API call code here
        response = # ... your API call ...
        
        if verbose
            println("✓ Received response of $(length(response)) characters")
        end
        
        return response
    catch e
        @error "Failed to call Claude API" exception=e
        rethrow(e)
    end
end

Reflection:

• Why is it better to put these functions in a package rather than copying them into each notebook?
• What other AI-related functionality might you add to this module?
• How does this relate to software engineering best practices?

Deliverable: Show that you can successfully import and use call_claude or call_gpt from your CAP6318 package.

Reflection Questions¶

Consider these questions as you work through the exercises:

1. On Emergence: We saw emergent behavior in both ABMs (segregation from simple rules) and LLMs (reasoning from next-word prediction). Are these the same kind of emergence? How do they differ?

2. On Agency: What does it mean for an LLM to be an “agent”? Does it have goals? Preferences? Beliefs? Or are these anthropomorphizations?

3. On Predictability: Rule-based ABMs are deterministic but produce unpredictable aggregate outcomes. AI agents are stochastic but often produce predictable responses. What are the implications for simulation and modeling?

4. On Control: With rule-based agents, we control them by writing code. With AI agents, we control them by writing prompts. Which gives us more control? Which is more brittle?

5. On Social Complexity: If AI agents become widespread in social and economic systems, how might that change the dynamics? Will they amplify existing patterns or create new ones?

We’ll explore these questions more deeply throughout the module.

Summary¶

In this lecture, we’ve:

✓ Distinguished between rule-based agents (traditional ABMs) and learning agents (LLMs)

✓ Understood how LLMs work at a high level (next-word prediction → general reasoning)

✓ Learned about transformer architecture and attention mechanisms

✓ Implemented basic LLM API calls in Julia (Anthropic and OpenAI)

✓ Explored emergent capabilities: chain-of-thought reasoning and tool use

✓ Compared the strengths and limitations of both agent paradigms

✓ Connected AI agents to broader themes in complex systems

Key Takeaways:

1. LLMs are trained on next-word prediction but develop general capabilities - an example of emergence

2. Prompting is programming - but in natural language with probabilistic outcomes

3. Chain-of-thought and tool use extend what agents can do beyond their training

4. Rule-based and learning agents are complementary - hybrid systems combine their strengths

5. Multi-agent AI systems represent a new frontier in computational social science

Next Lecture: We’ll explore how to augment AI agents with external knowledge using Retrieval Augmented Generation (RAG), connecting to information networks and knowledge graphs.