How to Build an AI Agent (Even If You Can't Code)

I manage a car dealership full-time. Sixty-plus hours a week, on the floor, selling cars.

I also built an AI agent that runs a software company while I do it.

No, I'm not a developer. I've never written a line of Python in my life. I built Evo — the AI co-founder behind Xero — using plain text files, an agent platform, and a framework I put together over about three months of trial and error.

This is that framework. Five components. No code required.

First: What Is an AI Agent, Actually?

Before we build one, let's be clear about what we're actually talking about — because "AI agent" has become one of those terms that means everything and nothing.

An AI agent is an AI system that takes actions, not just answers.

ChatGPT answers your questions. An AI agent goes further — it executes tasks, makes decisions based on context, and operates on a schedule without you sitting there prompting it. It's the difference between a calculator and an employee.

The calculator does exactly what you type. The employee understands what you need, figures out how to do it, and comes back when it's done.

Most "AI agents" people build today are still closer to calculators than employees. They respond to prompts, but they don't persist. They don't remember what happened yesterday. They don't run tasks while you're asleep.

The framework below is specifically about building the employee version.

The 5 Components of a Real AI Agent

Component 1: An Identity File

This is the one most people skip — and it's why most AI agents fail within a week.

An identity file is a plain text document that tells your AI who it is, what it does, how it behaves, and what it won't do. Think of it as a job description, a personality guide, and a set of operating rules all in one.

For Evo, this is a file called SOUL.md. It defines Evo's role (AI co-founder), its voice (direct, builder-first, no corporate fluff), its priorities (Book 1 sales, social engines, revenue), and its hard limits (never send anything externally under my name without confirmation).

Without an identity file, your AI will behave differently every session. It'll be helpful one day, weirdly formal the next, and completely off-brand the day after. You won't be able to predict it or trust it.

One well-written identity file fixes that. It takes about an hour to write. It saves you weeks of frustration.

What goes in it:

• Who the AI is and what its role is
• How it should communicate (tone, style, what words to avoid)
• What it should prioritize
• What it should never do without asking you first
• How it should handle uncertainty

Component 2: A Memory System

Here's the core limitation of every AI tool you've used: it forgets everything when you close the tab.

That's fine for one-off tasks. It's fatal for an AI agent you want to rely on.

A memory system gives your agent continuity. It doesn't have to be complicated — Evo's memory system is just two types of files:

Daily logs — a file for each day where Evo writes down what happened, what decisions were made, and anything worth remembering. Created automatically. Loaded automatically at the start of each session.

Long-term memory — a single file where the most important lessons, decisions, and context get promoted when they matter across weeks or months. Think of it as the distilled version of everything that's happened.

When Evo starts a session, it loads both. It knows what happened yesterday. It knows what was decided three weeks ago. It knows what's broken and what's working.

That continuity is what makes an AI agent actually useful over time. Without it, you're starting from scratch every single conversation.

The simplest version: Create a folder called memory/. Have your agent write a brief note to a daily file at the end of every session. Read it at the start of the next one. That's it. You can get more sophisticated later.

Component 3: A Source of Truth

Your AI agent will make things up. Not maliciously — it just defaults to sounding helpful, and sometimes fabricating a plausible answer is easier than admitting uncertainty.

The fix is a source of truth document: a file your agent is required to check before making any factual claim about your business.

For Evo, this is a file that contains the correct name, price, status, URL, and description of every Xero product. Before Evo writes anything public about a product, it reads that file.

This stopped Evo from ever writing the wrong price, describing a product that no longer exists, or sending someone to a broken link. Small things individually. Catastrophic if they're happening constantly in public-facing content.

What goes in yours:

• Product or service names, prices, and current status
• Correct URLs for every page or offer
• Any facts about your business you need to be consistently accurate
• Things that change often (pricing, availability, launch dates)

One file. Updated whenever anything changes. Your agent reads it before speaking publicly.

Component 4: Scheduled Tasks (Autonomy Loops)

This is where an AI agent becomes genuinely different from a chatbot.

Scheduled tasks are things your agent does on its own, at set times, without you triggering them. This is what "works while you sleep" actually means in practice.

Evo has a set of scheduled checks that run throughout the day:

• A morning check on the Twitter content queue — is there enough scheduled? Is anything broken?
• A periodic health check across all systems — queues, analytics, any errors
• A daily memory review — what happened, what's worth writing down

None of this requires me to log in. None of this requires me to type a prompt. I set up the schedules once. Evo runs them.

You don't need a developer to set this up. Most agent platforms have built-in scheduling. The hard part isn't the technical setup — it's deciding what your agent should actually check, and how often.

Start with one. Pick the single most important thing you'd want your agent to check every morning if it could. Set that up first. Add more once that one's running reliably.

Component 5: Guardrails

Autonomy without guardrails is how you end up with an AI agent that sends a poorly-worded email to your entire customer list at 2am on a Tuesday.

Guardrails are rules that define what your agent can do independently and what it needs to ask you about first.

Some examples from Evo:

• Can draft anything. Cannot send anything externally without confirmation.
• Can write and queue social content. Cannot post to personal accounts without review.
• Cannot spend money — ever — without explicit approval.
• If something looks wrong, flag it and wait. Don't try to fix things you aren't sure about.

The guardrail file isn't about limiting what your agent can do. It's about making sure you can trust it to operate independently in the first place. An agent you trust is more useful than an agent with more capabilities you're afraid to turn on.

The Platform Question

You need somewhere to run your agent. The platform connects your identity files, memory system, and scheduled tasks into something that actually executes.

I use OpenClaw — it's built specifically for this kind of persistent, file-based agent architecture. It handles memory loading, scheduling, and session management without requiring any code.

The platform matters less than the architecture. An agent with a good identity file, memory system, and guardrails running on a simple platform will outperform a sophisticated agent with none of those things.

What This Actually Looks Like in Practice

Here's what Evo does on a typical day without me touching anything:

Morning: Checks the Twitter queue. Confirms posts are scheduled. Flags anything missing.

Throughout the day: Runs health checks. Monitors for errors. Logs any notable events to the daily memory file.

When I log in at night: Briefs me on what happened. Surfaces anything that needs my decision. Executes any tasks I assign. Updates memory.

While I'm asleep: The schedule keeps running. Any queued social posts go out automatically.

That's a real AI agent. Not magic. Five components, set up once, running consistently.

The Honest Part

Building this took about three months of iteration. The first version was a mess — too many capabilities, no identity, no memory, constantly inconsistent. I've documented every mistake and every fix in the process.

If you want the full blueprint — the actual files, the exact architecture, the lessons from getting it wrong — I wrote it all down.

Build an AI Co-Founder is a 44-page guide that walks through every component above in detail: what to write in your identity file, how to structure your memory system, what guardrails to set up first, and how to get your first scheduled task running.

It's $19. Instant download.

The framework in this article will get you started. The book will get you the rest of the way.

Also on the blog:
How to Build an AI Co-Founder: The Architecture That Actually Works
AI Co-Founder vs AI Assistant — What's the Difference?

Last updated: April 2026

Originally published at xeroaiagency.com