How to Be an AI Agent Engineer: A Practical Guide
Last month I needed to automate lead follow‑up for my consulting biz, but I kept getting stuck with brittle Zapier automations chains that broke whenever a prospect used a weird signature line. After wrestling with those failures for two weeks I decided to build a tiny self‑hosted AI agent that could read incoming emails, draft a reply, and push the outcome into my CRM without any third‑party automation glue. By the end of this guide you’ll be able to spin up the same kind of agent, tweak it for your own workflow, and know exactly where to look when it misbehaves.
How do you handle email parsing without breaking on weird formats?
Email bodies are a mess: signatures, disclaimers, quoted threads, and HTML that looks like it was designed in 2003. The first version of my agent used a simple regex to pull out the plain‑text snippet above the signature. It worked for 80% of messages but choked on the rest, leaving the agent with a blank input and causing it to hallucinate a reply. I switched to the BeautifulSoup library in Python, which lets me strip tags, then I applied a two‑step heuristic: first look for a line that contains “Thanks” or “Best” and treat everything before it as the message body; if that fails, fall back to the longest contiguous block of non‑quoted text. This approach cut parsing failures from 20% to under 2% in my test set of 500 real outreach emails.
One‑sentence paragraph: The heuristic is dumb but it works.
What most guides get wrong about agent memory
Most tutorials treat memory as an afterthought, showing you how to slap a vector store onto an agent and then never mention the cost of keeping that store in sync. In practice, if you let the agent accumulate every email it ever sees, the embedding index grows linearly and your query latency spikes after a few thousand entries. I learned this the hard way when my agent’s response time jumped from 300 ms to over 2 seconds after processing just 2 000 messages. The fix is to bound memory: keep a rolling window of the last N conversations (I chose N = 50) and periodically summarize older interactions into a single “topic” embedding that represents the gist. This keeps the index size constant and the latency flat.
Concrete example: building a lead‑follow‑up agent with LangChain and SendGrid
Below is the exact flow I run on a $5/mo DigitalOcean droplet. First, install the dependencies:
pip install langchain sendgrid beautifulsoup4 python-dotenv- Create a
.envfile with your SendGrid API key and a placeholder OpenAI key (you can replace it with any compatible LLM endpoint). - Save the script as
agent.pyand run it withpython agent.py.
import os
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain.tools import Tool
from langchain_openai import ChatOpenAI
from sendgrid import SendGridAPIClient
from sendgrid.helpers.mail import Mail
from bs4 import BeautifulSoup
import re
def parse_email(raw: str) -> str:
soup = BeautifulSoup(raw, "html.parser")
text = soup.get_text()
# look for signature line
lines = text.splitlines()
for i, line in enumerate(lines):
if re.search(r"(?i)^(thanks|best|regards|sincerely)", line.strip()):
return "\n".join(lines[:i]).strip()
# fallback: longest block without > quoting
blocks = re.split(r"(?:^|\n)>.*", text, flags=re.M)
return max(blocks, key=len).strip()
def draft_reply(context: str) -> str:
llm = ChatOpenAI(temperature=0.7, model_name="gpt-4o-mini")
tools = [
Tool(
name="CRMUpdate",
func=lambda x: "updated",
description="Stub – replace with real CRM call"
)
]
agent = create_openai_functions_agent(llm, tools, prompt="You are a helpful sales assistant. Draft a short, polite reply based on the context.")
executor = AgentExecutor(agent=agent, tools=tools, verbose=False)
return executor.invoke({"input": context})["output"]
def send_via_sendgrid(to_addr: str, subject: str, body: str):
sg = SendGridAPIClient(os.getenv("SENDGRID_API_KEY"))
message = Mail(
from_email=os.getenv("FROM_EMAIL"),
to_emails=to_addr,
subject=subject,
plain_text_content=body
)
return sg.send(message)
# ---- main loop ----
while True:
raw = input("Paste raw email (or 'quit'): ")
if raw.lower() == "quit":
break
body = parse_email(raw)
reply = draft_reply(body)
print("\n--- Draft reply ---\n" + reply)
# In production you would extract the sender address from headers
send_via_sendgrid("example@prospect.com", "Re: Your inquiry", reply)
What this script does: it reads a raw email you paste, strips signatures using the heuristic from the previous section, asks the LLM to draft a reply, and then (in a real run) fires that reply through SendGrid. The CRM update tool is just a stub; you’d swap it for a real HTTP call to HubSpot’s CRM, Pipedrive, or whatever you use.