How to Create an AI Agent: A Practical Blueprint for Solo Operators

Last month I needed to automate lead follow–up for my freelance design biz, and I realized copying‑pasting prompts into ChatGPT wasn’t cutting it.

By the end of this guide you’ll have a working agent that can fetch leads, draft emails, and log replies—no PhD required.

How do you keep the agent from hallucinating pricing?

One of the first things I noticed was that the agent would sometimes invent a price for a service that didn’t exist. It would say “$150 for a logo redesign” when my actual rate is $80. This happens because the model tries to fill gaps with plausible‑sounding numbers.

To stop this, I gave the agent a strict lookup table. I stored my service‑price list in a simple Airtable base and told the agent to consult it before quoting anything. The prompt now includes a line like: “If the user asks for a price, return the exact value from the Airtable table named ‘Services’; do not guess.”

That small change cut hallucinations by about 90 %. The agent still gets creative with wording, but the numbers stay true.

What most guides get wrong about agent memory

Many tutorials treat memory as an afterthought. They show you how to feed the previous message back into the model, then call it a day. In practice, that approach blows up after three or four turns because the context window fills with irrelevant chatter.

What works better is a two‑layer memory system: a short‑term buffer for the last two exchanges and a long‑term store for key facts like the lead’s name, company, and budget. I keep the short‑term buffer in the model’s context and push the long‑term facts into a separate Make.com scenario that writes to a Google Sheet.

When the agent needs to recall a lead’s budget, it pulls the row from the sheet instead of scanning the whole chat history. This keeps the prompt short and the responses fast.

— and good luck finding docs for this —

A concrete named example: building the agent with GPT-4o and Make.com

Here’s the exact stack I use today:

• GPT-4o for reasoning and language generation.
• Make.com to orchestrate calls, fetch data from Airtable, and write logs.
• Airtable as the source of truth for services, prices, and lead records.
• Google Sheets as a lightweight long‑term memory store.

The flow starts when a new lead arrives via a webhook from my site’s contact form. Make.com triggers, grabs the lead’s name and email, then asks GPT-4o to draft a follow‑up email.

Here’s the prompt I send to the model (note the bold tool name on first mention only):

You are a polite sales assistant. Use the lead data provided to write a short follow‑up email. Reference the lead’s first name, mention their company, and propose a 15‑minute call. Do not invent prices or services. If the user asks for cost, reply only with the exact figure from the Services table in Airtable.

After the model returns the draft, Make.com posts it to Gmail as a draft email, logs the timestamp and lead ID to the Google Sheet, and waits for my reply. If I hit “Send”, the scenario marks the email as sent; if I edit, it updates the draft.

Cost breakdown (as of 2026):

• GPT-4o: $0.06 per 1 k tokens. My average call uses about 800 tokens → roughly $0.05 per interaction.
• Make.com: Free tier gives 1 000 operations/mo; I use about 300 → free.
• Airtable: Plus plan $12/mo (enough for 5 bases and 12 k records).
• Google Sheets: free with my Google account.

So the variable cost is under $0.10 per lead, and the fixed monthly spend is about $12.

I love how the built‑in memory store lets me persist conversation state without extra code.

How to debug when the agent loops or drops context

Even with a solid design, things break. The most common symptom I see is the agent repeating the same sentence over and over, or suddenly forgetting the lead’s name after two turns.

First, check the Make.com scenario logs. If you see an empty payload coming from the webhook, the trigger is mis‑configured—maybe the form changed and stopped sending the lead_name field. Fix the mapping and re‑run.

Second, look at the token count sent to GPT-4o. If the prompt exceeds 6 k tokens, the model starts truncating the beginning, which can drop the system instruction that tells it not to hallucinate. I keep the prompt under 2 k tokens by storing long facts in the sheet and only passing the lead’s ID.

Third, verify that the Airtable lookup is returning a value. A missing price will cause the agent to fall back to its own guess, which often leads to wild numbers. I added a fallback step that sends a Slack alert if the lookup returns empty.

(which, yes, is annoying) but it saves me from sending a quote of $10 000 for a logo.

Price check: what you’ll actually spend each month

Let’s put the numbers in a table‑like list for clarity.

• GPT-4o usage: ~150 leads/mo × 800 tokens × $0.06/1k = $0.72.
• Make.com: free tier covers my 300 operations.
• Airtable Plus: $12/mo.
• Google Sheets: $0.
• Optional: Slack alerts (free tier).

Total: about $13 per month.

I think $19/mo for a no‑code agent builder that does the same thing is overpriced for a solo operator, but your mileage may vary.

Why I still prefer the blueprint over building from scratch

After walking through the steps, you might wonder why anyone would buy a pre‑made package. The answer is time. The first version I built took me two weekends of trial‑and‑error, mostly debugging the Make.com webhook and figuring out the Airtable field names.

The blueprint at deepusecase.com/vault/ai-agent-builder-kit bundles the exact Make.com scenario, the Airtable base template, and the prompt library. You can import it, tweak the pricing table, and be live in an afternoon.

For more on this exact angle, deeper coverage of AI agent platforms.

If you’d rather skip the build and deploy a working version in an afternoon, we’ve packaged this workflow as a blueprint at deepusecase.com/vault/ai-agent-builder-kit.