Building AI Agents: The System That Automates 60% of One Entrepreneur’s Workload

Want to build AI agents into your workflow? Have you experimented with building one-size-fits-all AI agents and been disappointed with the results?

In this article, you'll discover how to build a custom system of AI agents that work with your business and processes.

This article was co-created by Keith Moehring and Michael Stelzner. For more about Keith, scroll to the end of this article.

The Hard Truth About Building AI Agents

The internet is full of “spin up an agent in six steps” tutorials that make the whole thing sound simple. Keith Moehring's first word of caution: it isn't.

Building an AI agent that reliably performs a specific task in the specific way you do requires real work. You have to provide context. You have to define the process. You have to iterate until the output matches what you actually want. And critically, the system you build has to be yours—not just a template you borrowed from someone else's workflow.

That said, Keith is clear that the upfront investment pays off. An agent that handles 80% of a task delivers real value. You supply the remaining 20%.

The agents also serve a second function Keith didn't fully anticipate: they act as a second brain. Everything is logged, consolidated, and queryable. If he can't remember when a project was completed or how a specific process was handled, he just asks. It's all there.

How AI Agents Help Your Business: Mini Case Study Examples

AI agents perform best when given a specific, repeatable task, not broad mandates. The layered value looks like this:

Entry Level: At this first level, you build agents to handle individual tasks: small, time-consuming actions you do regularly. Each agent is purpose-built to execute that one task reliably and repeatedly.

Intermediate Level: At the next level, you can build agents that coordinate those task-level agents, giving them direction and stringing their outputs together into larger workflows.

Advanced Level: At the highest level, orchestration agents do the work of managing everything.

Keith triggers his orchestration agent, Leo, at the start of each month. He gives Leo one prompt, and Leo knows exactly what to do, which sub-agents to activate, and in what order.

Set up all the client tasks and start executing on the work for all distributor clients this month.

The month’s asks are created in ClickUp, emails are drafted, and projects are started. Keith just reviews the output. This approach has cut what would normally take Keith two weeks down to one hour on the first day of the month.

Keith's first and favorite agent handles a task he consistently neglected: post-meeting follow-through. After client meetings, he'd jump straight to the next thing and lose track of action items and decisions. The agent now handles everything automatically.

Here's how it works:

Keith uses Granola for meeting notes, which has a Model Context Protocol (MCP) connector that Cursor can tap into.

Every meeting is named using the client's acronym followed immediately by an underscore and a description. For example, a meeting for a client with code “L2” would be named “L2_strategy_call”. This naming convention is documented in the Reference folder, so the agent knows exactly how to search for meetings by client.

The first line of each Granola note describes what the meeting is about: a project discussion, a strategy session, or an internal check-in. That label is what the agent reads to categorize and route the note correctly.

When Keith triggers the process, the agent pulls up the Granola API, retrieves all meeting notes from the previous week, and cross-references them against his client list. For each meeting it finds, it identifies the client, pulls the full notes, converts them to a text file, and saves them to that client's folder inside the Clients directory.

It then reviews the notes for action items and to-dos Keith owns, and creates tasks in ClickUp with full context—the client name, what was discussed, and what needs to happen—so Keith doesn't have to reconstruct any of that himself.

All of this is driven by a single prompt.

#1: Use Your Org Chart to Outline Responsibilities

Before you build anything, Keith recommends getting clear on how your business actually operates.

His preferred starting framework is an accountability chart. The structure is simple: at the top is the CEO or owner, below that an integrator or operations lead, and below that the three core business functions of sales and marketing, operations, and finance, then the departments and roles beneath each.

Each role has a reason for existing, a set of responsibilities it owns, and a list of specific tasks it performs on a daily, weekly, monthly, and quarterly basis. Those tasks are your target.

For entrepreneurs who wear every hat, Keith suggests Ninety.io, which offers a free accountability chart feature. You can also use Claude to generate one: describe all your business functions, your roles, and your recurring tasks, and ask it to visualize the structure. Keith has his printed and hanging on his wall.

I want you to create a visual accountability chart for my business.
I'll describe my business functions, roles, and recurring tasks below — then I want you to visualize the structure as a clean, printable org/accountability chart I can hang on my wall.
Here's my information:
Business functions: [e.g., Marketing, Sales, Client Delivery, Operations, Finance]
Roles (who owns each function — can be you wearing multiple hats): [e.g., CEO/Visionary, Marketing Manager, Project Manager, Bookkeeper]
Recurring tasks under each role: [e.g., under Marketing: write weekly newsletter, manage social media, run paid ads]
Please organize this into a hierarchical accountability chart that shows: The top-level role or owner at the top; Each business function as a column or section; The role responsible for each function; The key recurring tasks under each role.
Make it clean, easy to read, and suitable for printing on a single page (landscape orientation if needed).
Use clear visual separation between functions.

If you work inside a larger organization rather than running your own business, the approach is simpler. Focus on your one role, map out your two or three core responsibilities, and list the tasks that fall under each. That hierarchy is your roadmap.

Once you have your chart, start with the tasks, not the agents. Pick one recurring action you do regularly that would be valuable to automate, and build your first agent around that.

Once that agent is working well, you build the second, and then the third. Each new task is faster to build because the foundational context you've already created can be reused.

#2: Set Up the Tech Foundation for Your AI Agent

Keith's system for building AI agents has three essential components: an AI model, a user interface, and a context layer.

Choose the AI Model

Keith uses Claude almost exclusively for this work, though he notes that OpenAI and Gemini are equally capable. The approach he describes is LLM-agnostic. What matters is giving it the right context to operate from.

One practical nuance: Keith switches models based on task complexity. For the majority of agent work, Cursor's built-in AI or his connected Claude account handles everything he needs. For advanced coding tasks, he switches to Claude Code. The ability to choose the right model for each job within the same interface is one of the things he values most about the setup.

Choose the User Interface

This is the piece most people miss. Keith uses Cursor, a downloadable code editor that connects an AI model directly to the files on your computer. He estimates he pays around $99 per month for access.

The interface has three panels: your folder hierarchy on the left, a chat panel on the right where you interact with the agent, and the file you're actively working on in the center.

When you open your project folder in Cursor, the AI gains access to everything inside it, and you work with it through natural language. Cursor also lets you connect your own Claude account directly, giving you the option to draw on your Claude subscription's token capacity instead of Cursor's built-in limits.

From a security standpoint, Cursor restricts the agent to the folder you've opened, so it can't access any other repositories. You can also set it to require your approval before making any changes to files, which Keith recommends when you're just getting started.

For teams, the most practical option is syncing the folder directory to GitHub. Team members pull the same files to their local machines and work from a shared context.

Establish the Context Layer

This is where the system's real power lives. Keith's context folder, which he calls L2 Ops, sits on his desktop and contains six subfolders:

Playbooks: SOPs written as AI instructions—what to do, in what order, and where to find what's needed Reference: background information about the business—naming conventions, technology in use, how files are organized Skills: reusable, step-by-step instructions for specific recurring actions (for example, exactly how to create a task in ClickUp, including what fields to populate and how) Templates: examples of what outputs should look like—blog posts, emails, reports Scripts: Python code for connecting to external APIs, such as pulling specific contact lists from HubSpot Clients: a folder containing one subfolder per client. Each client subfolder holds all the context the agent needs to work on that client's behalf: the client's full name, the acronym Keith uses for them, where their folders live in Google Drive, and who the main priority contacts are. This is also where consolidated meeting notes are stored after processing, providing the agent with a running record of every client conversation.

The AI builds a mental map of this folder structure over time. When running a task, it knows exactly where to look for what it needs and proceeds through the process without being told which file to check.

#3: Build a Playbook to Guide the AI Agent’s Actions

Playbooks are the SOPs of your agent system. They're not written for humans; they're written as instructions for the AI, telling it what to do, in what order, and where to find what it needs.

The process Keith recommends for creating one:

Document the Task

Before you ask the AI to build anything, you need to define a few things. Write out how you currently approach the task, even a rough numbered list of steps will do. Gather any templates or examples of what the final output should look like. Identify the required technologies and ensure you have the necessary connections in place: API keys, MCP connectors (such as Granola's API for meeting notes), or other access points. If you're not sure how to set those up, you can ask the AI to walk you through it during the build process.

Open the User Interface and Give the AI the Details

Once your prep work is done, go into Cursor and give it the full picture: here's the task, here's my approach, here's my process, here's a template of the output, here's the tech involved. Then tell it you're using the WAT framework (Workflows, Agents, and Tools) and ask it to help you build the agent step by step.

The AI will draft a full document outlining how it will build the agent, which files it will create, and how each piece will work. You review the plan, highlight anything that needs to change, and refine it until it matches your vision. Once it looks right, you hit the Build button.

The build process can take anywhere from a minute to ten minutes depending on complexity. You can watch the AI work through it in real time as it troubleshoots connections, updates files, and adjusts the plan as new information comes up. By the end, you have a minimum viable agent you can test.

Test Your AI Agent With a Real Example

Before you declare the agent ready, run it on a small, contained sample. Keith's meeting notes agent provides a useful illustration of what a working agent looks like in practice.

#4: Tips to Get the Whole System Working for You

Start Small

The fastest path to a working system is to start with your simplest, most repetitive task, not your most complex one. Starting with a broad ask like “build me a content marketing agent” will almost always produce something you can't use. The AI will build what it thinks you want rather than what you actually do. The more complex the initial request, the harder it is to untangle later.

Instead, break complex workflows into their smallest components.

If writing a piece of client content requires online research, an asset library check, and a subject matter interview, build three separate agents: one for each step. Once each does its job reliably, stack them in sequence. That sequential output is far more controllable and far more powerful.

Build From the Bottom Up, Not the Top Down

Once you have a few task-level agents working, you can layer an orchestration agent on top of them. Keith's orchestration agent, Leo, knows how to interpret high-level commands and delegate work to the right sub-agents. But Leo only works because the sub-agents beneath him are already reliable. The orchestration layer comes after the foundational work is done, not before.

Automate the Triggers

Once agents are built, you don't have to trigger them manually every time.

Cursor Automations allows you to set agents to run on a schedule or in response to specific conditions. For example, at noon every Monday, or when a certain type of email arrives. For GitHub-based setups, cron jobs serve the same function.

Other Notes From This Episode

Connect with Michael Stelzner @Stelzner on Facebook and @Mike_Stelzner on X. Watch this interview and other exclusive content from Social Media Examiner on YouTube.

Where to subscribe: Apple Podcasts | Spotify | YouTube Music | YouTube | Amazon Music | RSS

✋🏽 If you enjoyed this episode of the AI Explored podcast, please head over to Apple Podcasts, leave a rating, write a review, and subscribe.

---

Stay Up-to-Date: Get New Marketing Articles Delivered to You!

Don't miss out on upcoming social media marketing insights and strategies! Sign up to receive notifications when we publish new articles on Social Media Examiner. Our expertly crafted content will help you stay ahead of the curve and drive results for your business. Click the link below to sign up now and receive our annual report!