AI AGENTS AND HOW TO BUILD THEM

They have gone from simple rule-based scripts to autonomous systems that learn, adapt, and make decisions. They’re no longer toys, they’re already reshaping industries.

Let’s break down what they are, why they matter, and how to actually build one.

What is an AI Agent?

An AI Agent is any system that can sense its environment, think (reason/learn), and act on that environment to achieve goals.

Think of it as a digital entity that runs on the Sense → Think → Act loop:

1. Sense – collect inputs (data, text, images, API calls).
2. Think – analyze, reason, and decide.
3. Act – execute actions (update database, flag fraud, recommend product).

Types of AI Agents

• Reactive Agents – simple “if-this-then-that” (like spam filters).
• Deliberative Agents – keep memory, plan ahead (like inventory optimization).
• Hybrid Agents – mix of both (fast responses + long-term planning).

Why Agents Matter for SMEs

For small and medium-sized businesses (SMEs), agents can automate decisions that normally need a team:

• Detecting fraud in transactions.
• Monitoring customer behavior.
• Automating financial reporting.
• Optimizing supply chains.

Example: Building a Fraud Detection AI Agent

Here’s a of a fraud detection agent. This uses machine learning to classify whether a transaction is fraudulent.

import boto3
import json

# Initialize AWS Bedrock client
client = boto3.client(
    service_name="bedrock-runtime",
    region_name="us-east-1"  # adjust region
)

# Fraud detection agent
class FraudDetectionAgent:
    def __init__(self, model_id="anthropic.claude-v2:1"):
        self.model_id = model_id

    def sense(self, transaction):
        """Receive transaction details (environment input)."""
        return transaction

    def think(self, transaction):
        """Use LLM reasoning on transaction data."""
        prompt = f"""
        You are a fraud detection agent.
        Transaction details: {transaction}
        Decide if this transaction looks suspicious.
        Return 'fraud' or 'legit' with reasoning.
        """
        response = client.invoke_model(
            modelId=self.model_id,
            body=json.dumps({"prompt": prompt, "max_tokens_to_sample": 200})
        )
        output = json.loads(response["body"].read().decode("utf-8"))
        return output.get("completion", "Unknown")

    def act(self, decision):
        """Perform action based on model output."""
        if "fraud" in decision.lower():
            print("Alert: Fraudulent transaction detected!")
        else:
            print("Transaction approved.")

    def run(self, transaction):
        data = self.sense(transaction)
        decision = self.think(data)
        self.act(decision)

# Example transaction
transaction_data = {
    "transaction_id": "TXN12345",
    "amount": 5000,
    "currency": "USD",
    "location": "Nairobi",
    "merchant": "Electronics Store",
    "time": "2025-09-24T20:00:00"
}

agent = FraudDetectionAgent()
agent.run(transaction_data)

What’s Happening Here?

• Sense: Reads transaction input.
• Think: Uses AWS Bedrock LLM (Claude, Llama, or Titan) to assess fraud risk.
• Act: Prints alert or approval.

This can be extended to:

• Store fraud alerts in a database.
• Notify via email/SMS.
• Auto-block high-risk transactions.

Conclusions

AI agents aren’t just hype, they’re becoming the invisible workforce of SMEs. By combining autonomy, adaptability, and real-time decision making, they can save businesses millions while unlocking growth.