The Core Stack for a Basic AI Agent
Forget the science fiction diagrams. A useful agent that actually does work for you has four simple parts: a trigger, a brain, a tool, and an action. That’s it. You don’t need a vector database or a multi-agent conversational framework to start seeing ai agents in action.
1. The Orchestrator (Trigger/Action): This is the switchboard that kicks things off and connects the other pieces. For operators, this means a no-code automation platform. My go-to is Make (formerly Integromat). You could also use Zapier, but I find Make’s visual interface and granular control over data structures much better for multi-step workflows. Its error handling is also clearer, which you’ll appreciate when things inevitably break. The free tier is fine for a quick test, but you’ll hit the 1,000 operations/month limit in a day. The $9/mo Core plan is where real work starts, and honestly, it’s a steal for what it can do.
2. The Brain (LLM): This is the large language model that does the thinking, summarizing, and writing. You’ll be using an API for this. The obvious choice is OpenAI‘s GPT-4 series. Yes, there are other options like Claude or Gemini, but OpenAI’s API is reliable, well-documented, and integrated into everything. You pay per token (basically, per word in and out), which for most small-scale agent tasks costs pennies per run.
3. The Tool (Data Source/Action): The brain is useless if it can’t interact with the outside world. A tool is anything that gets data or performs an action. This could be a Google Search API to find a website, an HTTP module to scrape a webpage, or an API call to your own CRM. For search, I often use SerpAPI. It’s not cheap — starting at $50/mo for 5,000 searches — but it reliably gets around captchas and returns clean, structured data from Google searches, which is a nightmare to do yourself.
4. The Memory (State): Where does the agent store its work? Don’t overcomplicate this. For 90% of solo operator use cases, the memory is a Google Sheet or an Airtable base. The agent reads a task from a row, does its work, and writes the result back into different columns in the same row. Simple, visible, and easy to debug.
What Most Guides Get Wrong About AI Agents
Most of the content you read about AI agents is written by academics or VC-funded startups selling you a dream. They talk about full autonomy and self-improving code. That is not the reality for operators trying to get work done in 2026.
AI Side Hustles
Practical setups for building real income streams with AI tools. No coding needed. 12 tested models with real numbers.
Get the Guide → $14
The biggest myth is the idea of the “autonomous” agent as a magic black box. You don’t just give it a vague goal like “get me more customers” and watch it work. That’s a fantasy. A real, working agent is a chain of very specific, prompted instructions connected to specific tools. It follows a script. Your job is to write a very good script.
My concrete gripe is the obsession with complex Python frameworks like LangChain or AutoGPT for simple business tasks. These tools are powerful, but they are massive overkill for researching a lead or drafting a social media post. You’ll spend a week learning the framework’s abstractions and debugging dependency issues just to do something you could have built in Make in two hours. For an operator, the goal is the outcome, not the technical elegance of the solution. Start with no-code tools. You can always graduate to code if you hit a hard ceiling, but you probably won’t.
The other trap is trying to build a single agent that does 20 things. Don’t. Build tiny, single-purpose agents. One agent to research leads. A separate agent to draft tweets from an article. Another to categorize support tickets. They are easier to build, infinitely easier to debug, and far more reliable than one monolithic “do-everything” bot.
A Concrete Example: The “Company Research” Agent
Let’s see some real ai agents in action. Here’s a common task: you have a list of company names in a Google Sheet, and you need to write a personalized first line for a cold email to each of them. Doing this manually takes 5-10 minutes per lead. We can build an agent to do it in 30 seconds.
Here is the operator playbook for this build in Make:
- Trigger: New Row in Google Sheets. Our scenario starts when we add a new company name to a specific sheet. The sheet has columns for ‘CompanyName’, ‘Website’, ‘Summary’, and ‘PersonalizedLine’.
- Action 1: Search for the Website. Use the SerpAPI module to perform a Google search for `{{CompanyName}} official website`. This gives us a list of URLs. We’ll take the first result.
- Action 2: Scrape the Website Content. Use Make’s built-in HTTP module to make a `GET` request to the URL from the previous step. This will pull the raw HTML of the company’s homepage. It won’t be pretty, but it’s enough. We then use a simple text parser to strip out the HTML tags, leaving us with the page’s text content.
- Action 3: The GPT-4 Brain. This is the core step. We send the cleaned text to the OpenAI module. My concrete love is how you can craft a precise prompt to get back structured data. Don’t just ask it to “summarize the company.” Give it a role and a specific output format.
Here is the exact prompt I use for this:
You are an expert B2B sales development representative. Your goal is to analyze the provided website text for a company named {{1.CompanyName}}. Your analysis will be used to write a highly relevant cold email.
Website Text:
"""
{{2.scraped_text}}
"""
Based ONLY on the text above, perform these two tasks:
1. **Company Summary:** In one clear sentence, what does this company sell and to whom?
2. **Personalization Angle:** Write one compelling sentence I can use in a cold email that shows I understand their business. The sentence must connect what they do to a potential pain point that my service (AI automation consulting) solves. Be specific.
Output your response in a valid JSON format with the keys "summary" and "personalization". Do not include any other text, explanation, or markdown formatting.
This level of prompt detail is non-negotiable.
5. Action 4: Parse the Response and Update the Sheet. The OpenAI module will output a JSON string. Use Make’s JSON parser to turn that into usable data fields. Then, use the Google Sheets `Update a Row` module to write the `summary` and `personalization` values back to the correct columns in our original sheet.