AI Agents: The Art of Digital Colony Building (or Why Your Next Workforce Might Look Like “The Settlers”)

Remember those countless hours spent playing strategy games like “The Settlers” or “Age of Empires” - good old days 😀 -? In these games, you’d orchestrate a complex network of specialized workers: farmers harvesting wheat and transferring to mills, millers grinding flour and transferring to bakeries, bakers crafting bread and transferring to shops, and merchants selling the final product. Each worker knew their role, understood their inputs and outputs, and worked autonomously within a larger economic system.

The Settlers: New Allies ©Ubisoft

Today, as we stand at the frontier of AI technology, I can’t help but see parallels between these virtual settlements and the emerging ecosystem of AI agents. Just as game workers manage resources efficiently, today’s AI agents are designed to handle specific tasks autonomously, creating what we might call a “digital workforce” - an interconnected network of AI -powered agents that work together to execute complex workflows.

But how exactly do these AI agents function and what makes them more than just chatbots?

The Evolution of AI Agents: From Simple Workers to Smart Specialists

Before diving deeper, let’s understand what makes today’s AI agents different from their predecessors.

Traditional old-school software agents, like the ones we have known for decades as rule-based chatbots or macros, operated using static, pre-programmed logic: “if X happens, do Y”.

A typical chatbot flow diagram ©MasterOfCode

Modern AI agents, powered by Large Language Models (LLMs) and machine learning, adapt to changing conditions, make decisions based on context, remember outcomes of previous actions and even collaborate with other AI agents to achieve complex goals.

Traditional vs. Modern AI Agents

The Building Blocks of Modern AI Agents

AI agents are not just LLMs plugged into a chatbot. They are designed to work autonomously within a structured system. Here are the essential components of today’s AI agents:

1. Foundation Models

Like the basic training every worker in your settlement receives, foundation models provide AI agents with broad knowledge and capabilities. These are typically LLMs (like GPT-4, Claude, Deepseek, etc.) that serve as the base layer of understanding and reasoning.

2. Specialized Training

Just as you wouldn’t expect a baker to mine coal, AI agents often undergo specialized training for specific tasks. This can include:

• Fine-tuning on domain-specific data
• Reinforcement learning from human feedback (RLHF)
• Few-shot learning capabilities for quick adaptability

3. Tool Use and Integration

Modern AI agents can interact with external tools and APIs, similar to how game workers use different buildings and equipments to enhance productivity. This might include:

• API calling capabilities for data retrieval and processing
• Web based information lookup
• Code execution for automated workflows
• Database access for storing and retriving data
• File system interactions for document management

4. Memory and Context Management

Unlike traditional agents, modern AI agents can maintain context across interactions and manage both short-term and long-term memory. Think of it as game workers remembering not just their current task but also previous experiences and lessons learned. This allows modern AI agents to remember past interactions, adapt to changing conditions and optimize their performance over time.

How AI Agents Collaborate: The Digital Settlement Model

Following our initial strategy game analogy, let’s look at how different types of AI agents work together:

1. Planning Agents

Like the overseer in your settlement, these agents handle high-level strategy and task decomposition. They can:

• Break down complex goals into smaller tasks
• Allocate resources and responsibilities
• Monitor progress and adjust plans

2. Specialist Agents

Similar to specialized game workers, these agents focus on specific tasks:

• Research agents that gather and analyze information
• Writing agents that create content and documentation
• Coding agents that write and debug software
• Data analysis agents that process and visualize data

3. Coordination Agents

Think of these as the market square in your settlement - they facilitate communication and resource exchange between other agents:

• Message routing and prioritization
• Resource allocation
• Conflict resolution
• Task scheduling

What Makes Modern AI Agents Different?

Unlike traditional software agents, modern AI agents bring several game-changing capabilities:

1. Natural Language Understanding

Instead of requiring specific commands or triggers, these agents can understand and act on natural language instructions, much like how you might give directions to a human worker.

2. Adaptability and Learning

Modern agents can learn from interactions and adjust their behavior, similar to how strategy game workers might find more efficient paths or resource combinations over time.

3. Reasoning and Problem-Solving

Rather than following fixed rules, these agents can reason about problems and create new solutions, much like how advanced game AI can adapt to unexpected situations.

4. Multi-Agent Collaboration

Like workers in a settlement coordinating to create complex products, modern AI agents can work together, sharing information and coordinating actions to achieve common goals.

The Product Person’s Challenges

As product people, integrating AI agents into our products presents unique challenges:

1. The Orchestration Challenge

How do we create systems where multiple AI agents can work together effectively? Like in strategy games, we need to ensure smooth resource flow and clear communication paths. We can use AI orchestration frameworks like LangChain to manage task delegation and coordination.

2. The Balance of Autonomy

When should agents work independently and when should they seek human input? This is similar to deciding which processes in your settlement should be automated versus manually controlled. We can define “confidence thresholds” where AI agents only escalate when uncertain.

3. The Trust and Verification Problem

How do we ensure agents are working correctly and producing reliable results? Like monitoring your settlement’s production chains, we need ways to verify agent outputs and catch potential issues. We can implement human-in-the-loop (HITL) validation for critical decisions.

Building Your Digital Settlement

When implementing AI agents in your product, consider these principles:

1. Start with Clear Workflows: Map out your “production chains” clearly - what are the inputs, processes and outputs for each agent?
2. Design for Collaboration: Create clear interfaces between agents, like the roads and storage buildings in your settlement.
3. Implement Feedback Loops: Build mechanisms for monitoring and improving agents’ performance, similar to how you’d optimize your settlement’s production chains.
4. Plan for Scale: Design your agent architecture to grow and evolve, just as you’d plan your settlement’s expansion.

The Future of AI-Powered Settlements

As AI technology continues to evolve, we’re moving toward increasingly sophisticated digital settlements where agents can handle complex tasks and collaborate seamlessly. The key to success will be in designing these systems to be both powerful and manageable, much like building a settlement in your favorite strategy game.

Remember, the goal isn’t to create a fully autonomous system that runs without human input, but rather to build a productive “settlement” where human intelligence and AI agents work together harmoniously, each contributing their unique strengths to achieve common goals.

After all, even in the most advanced strategy games, the player’s role as the strategic decision-maker remains crucial. In the same way, our role as product people is to be the architects of these digital settlements, ensuring they serve their intended purpose while continuing to evolve and improve.

Bonus Section: Putting Theory into Practice, Building a Job Application Assistant

Let’s take our strategy game analogy one step further and build a practical example of how AI agents can collaborate in real-world applications. Imagine constructing a “digital settlement” where each AI agent has a specialized role, working together to assist job seekers in analyzing job opportunities and improving their applications.

For this, we’ll use CrewAI, a popular open-source framework for orchestrating multiple AI agents (I know there are low-code platforms like n8n, which provide strong visual workflow builders, but I chose CrewAI for this case because of its human-readable format in defining agents and tasks).

Our goal? An AI-driven job application assistant. Think of it as a structured system where different AI agents - just like specialized workers in a well-functioning economy - analyze job descriptions, assess candidate profiles and provide tailored application advice.

Defining the AI Agents

Each AI agent in our system serves a distinct purpose, just as workers in a strategy game contribute to the broader ecosystem:

1. Job Analysis Specialist: an experienced job market analyst with deep understanding of various industries and roles.
2. Profile Analysis Specialist: a career coach with years of experience in helping professionals present their experience effectively.
3. Career Matching Specialist: a senior career advisor who specializes in helping candidates position themselves effectively for roles.

Building the AI Crew

Below is an implementation using Python and CrewAI, where each agent is assigned specific tasks in the job application workflow.

## for more details, check --> https://github.com/sdogantekin/ai-agents
from crewai import Crew, Task, Agent, LLM
from ApiKeys import get_deepseek_api_key
from crewai_tools import ScrapeWebsiteTool
from CustomDuckDuckGoTool import CustomDuckDuckGoTool

# in this example, we use the deepseek-chat model, but you can use any other model you have access to (even the local ones)
deepseekllm = LLM(model='deepseek/deepseek-chat',temperature=1.0,api_key=get_deepseek_api_key())
# llamaLLM = LLM(model="ollama/llama3.2",base_url="http://localhost:11434") # sample reference to local LLama model

# these are tools that we will assign to the agents
scrape_tool = ScrapeWebsiteTool() # this tool will enable an agent to scrape a given website
search_tool = CustomDuckDuckGoTool() # this tool will enable an agent to search the web for a given query

# this the agent that will analyze the job description
job_analysis_specialist = Agent(
    role='Job Analysis Specialist',
    goal='Analyze job descriptions thoroughly to extract key requirements and company profile',
    backstory="You are an experienced job market analyst with deep understanding of " 
        "various industries and roles. You excel at breaking down job descriptions and target company profiles "
        "to identify both explicit and implicit requirements.",
    verbose=True,
    allow_delegation=False,
    tools=[scrape_tool, search_tool],
    llm=deepseekllm
)

# this the agent that will analyze the candidate profile
profile_analysis_specialist = Agent(
    role='Profile Analysis Specialist',
    goal='Analyze candidate profiles to identify strengths, weaknesses and unique selling points',
    backstory="You are a career coach with years of experience in helping professionals "
        "present their experience effectively. You excel at identifying transferable "
        "skills and unique value propositions.",
    verbose=True,
    allow_delegation=False,
    tools=[scrape_tool, search_tool],
    llm=deepseekllm
)

# this the agent that will provide matching advice
career_matching_specialist = Agent(
    role='Career Matching Specialist',
    goal='Evaluate job-candidate fit and provide strategic application advice',
    backstory="You are a senior career advisor who specializes in helping candidates "
        "position themselves effectively for roles. You excel at identifying gaps "
        "and suggesting concrete steps for improvement.",
    verbose=True,
    allow_delegation=False,
    llm=deepseekllm
)

# this is the task that will analyze the job description, this task is assigned to the job_analyzer agent
analyze_job = Task(
    description="Analyze the job posting at {job_url} and also the company related to it."
        "Focus on: "
        "1. Key technical requirements "
        "2. Soft skills and cultural fit indicators "
        "3. Implicit requirements and nice-to-haves "
        "4. Company business objectives, products, target market segment, market position, customers, success stories, values and culture signals "
        "Provide a structured analysis that can be used by the matching specialist. ",
    expected_output="Structured analysis of job requirements and target company including necessary "
        "skills, qualifications experiences and company profile including its culture.",
    agent=job_analysis_specialist
)

# this is the task that will analyze the candidate profile, this task is assigned to the profile_analyzer agent
analyze_profile = Task(
    description="Analyze the candidate profile at {profile_url}."
        "Focus on: "
        "1. Technical skills, experience and education "
        "2. Demonstrated soft skills and personality traits "
        "3. Career progression and achievements "
        "4. Unique selling points and personal brand "
        "Provide a structured analysis that can be used by the matching specialist.",
    expected_output="Structured analysis of candidate profile including key skills, experiences, contributions, interests and "
        "communication style.", 
    agent=profile_analysis_specialist
)

# this is the task that will provide matching advice, this task is assigned to the matching_specialist agent
provide_matching_advice = Task(
    description="Using the analyses from both the job and profile specialists:"
        "1. Evaluate the overall match percentage "
        "2. Identify key strengths to emphasize "
        "3. Point out gaps that need addressing "
        "4. Provide specific recommendations for: "
        "- Resume adjustments "
        "- Cover letter points "
        "- Interview preparation "
        "- Skill development priorities "
        "Provide actionable advice that the candidate can implement immediately.",
    expected_output="Detailed matching advice including strengths, gaps and "
        "recommendations for resume, cover letter, interview preparation and skill development.",
    context=[analyze_job, analyze_profile],
    agent=career_matching_specialist
)

# this is our crew (group of agents and tasks) that will handle the all process
application_crew = Crew(
    agents=[job_analysis_specialist, profile_analysis_specialist, career_matching_specialist],
    tasks=[analyze_job, analyze_profile, provide_matching_advice],
    verbose=True
)

# this will make our agents to work on the tasks using the given inputs
result = application_crew.kickoff(
        inputs={
            "job_url": "https://www.linkedin.com/jobs/view/4136748557", # job posting url
            "profile_url": "https://www.linkedin.com/in/serkandogantekin" # candidate profile url
        }
    )

This code demonstrates several key concepts we discussed:

1. Specialized Agents: Each agent has a specific role and expertise, like workers in our strategy game.
2. Clear Workflows: Tasks are clearly defined with specific inputs and expected outputs.
3. Collaboration: Agents work together, passing information through the orchestration.
4. Tools: Each agents has tools that they can use while working on their assigned tasks.
5. Autonomous Operation: Each agent can work independently while contributing to the larger goal.

When executed, the workflow:

1. The Job Analysis Specialist Agent extracts job requirements, insights and company profile.

2. The Profile Analysis Specialist Agent evaluates the candidate’s experience and strengths.

3. The Career Matching Specialist Agent compares both datasets provided by the two other agents and provides tailored application advice.

The result? A structured and AI-powered job application assistant that helps candidates improve their resumes, cover letters and interview preparation.