There is a whole industry right now trying to sell you a complicated answer to a simple question: what is an AI agent?
Frameworks, RAGS, orchestration, vector this, loop that. It's a lot...
But it's much simpler than that, my friend.
An AI agent can be boiled down into a stack of six elements.
Each one maps to something you already understand.
Now obviously, there is more to it once you ramp up, into the world of AI everything... but this guide is a primer to get the right mental model.
With that out of the way, lets dig into it.
Claude, GPT, Gemini. Pick one. It has close to all of the world's written-down information inside it. And on its own, it just sits there. It knows how a good weekly summary reads, how Salesforce's API works, what a polite follow-up email sounds like. It doesn't know you want any of those things, and it can't touch any of them. Knowing is not doing.
"Summarize my last week."
"Draft a blog post from this voice note."
"Find this contact and log the call."
The prompt is the thing you want done. The smartest person in the world still sits there until you tell them what you actually want.
"Summarize my week" means something different for you than for anyone else.
A skill is your context written down:
Knowing about plumbing doesn't make you a plumber. A skill is the difference between knowing about the job and knowing your version of it.
Now it knows what to do and how you'd do it... Does it have the right utilities and tools to DO the thing?
Without arms and a wrench the plumber can only know how to fix the pipes. They need the toolbox and eyes/ears/hands etc.
In agent land, this usually means small commands that touch real systems: a crm command that looks up a contact, a calendar command that pulls your week, gh to open a pull request. A plumber with no wrench is just a person who knows a lot about pipes.
Tools in hand, and the front door is still locked. Access is the API keys, scoped tokens, and MCP connections that let the tools actually get in. It's also the safety layer: the keys decide which doors open. Hand the agent a key that reads contacts and adds notes, and there is no key to the delete-everything room.
By default, the brain starts every job with amnesia. Each run is a blank slate. Memory is how previous work carries forward: notes the agent writes for itself, logs of past runs, files that record what was decided and why. It's the notebook a contractor keeps in the truck: what got done last visit, which parts this house needs, what the owner said to never touch.
Model, prompt, skills, tools, keys, memory. Stack those six and you have yourself a fancy new AI agent.
The model is the easy part: pay for a subscription from a frontier lab like OpenAI or Anthropic.
Then it's time to manifest your agent.
Start with the least technical question possible: what did you do before AI?
For any recurring task, you already have a process. You open a few tabs, pull some numbers, format them a certain way, send them somewhere. That sequence of steps is the skill. You've just never had to say it out loud.
So say it out loud. Dictate the whole flow (every step, every "and then I check X") and hand that to the model along with a pointer to the Claude skills docs. Tell it to turn your description into a skill.[1] You don't write the skill by hand. You describe your job and let the model format it.
A skill is a plain-language recipe: here's the goal, here are the steps, here are the tools you'll need along the way. That last part matters, because a recipe is useless if you can't reach the ingredients. Which brings us to access.
Skills can be super simple markdown files OR they can be a robust set of instructions and code that will execute on demand for your agent.
A skill that can only talk is a chatbot.
To make it a useful agent, it needs to reach your real systems: your email, your CRM, your calendar, whatever software you actually live in.
Access can come in many forms:
Rolling your own custom CLI is the option worth understanding.
The mechanism is unglamorous: get an API key, then have the model write you a tiny CLI that calls the third-party service.
The CLI is the wrench in the agent's hands; the API key unlocks the building. Skip the platform. Build a single command that does one job.
For example, a tiny crm CLI pointed at a Salesforce instance:
# The agent doesn't call Salesforce directly.
# It runs a small command you control.
crm find-contact --email "jane@acme.com"
crm add-note --contact 00Q5f000 --text "Renewal call booked"Ask Claude or Codex to build it, and it will. Whether it's a local CLI or a backend serverless function is an implementation choice; the agent can help you build and ship either one.
Most people skip this part, and it's the one that matters most.
If you hand an agent your Salesforce token, it can do everything that token can do, including deleting records you never wanted it near. The fix is to scope permissions down to only what the skill needs.
Some providers let you mint fine-grained tokens. Many don't, and their role-based access control is too coarse to help. When the provider can't constrain it, you constrain it. That's what the tiny CLI is for: a shim layer sitting between the model and the raw API.
--- title: The shim is the allowlist --- flowchart LR Agent[Agent] --> CLI[Your CLI / shim] CLI -->|only allowed actions| API[Third-party API] CLI -.->|blocked: delete, admin, billing| API
The shim exposes find-contact and add-note. It just doesn't expose delete-everything. The model can't call what you never built. Your custom command becomes the allowlist, and the blast radius shrinks to exactly what you decided it should be.[2]
"Harness" sounds like jargon. It isn't. A harness is a computer running Claude or Codex (or another AI tool) on your behalf. That's the whole definition. In the stack analogy, it's the body the brain gets to use. Without it, all that knowledge just sits there.
The loop it runs is boring in the best way:
flowchart LR Prompt[Your prompt] --> Harness[Harness: model on a computer] Harness --> Skill[Match a skill] Skill --> Tools[Call the CLIs it references] Tools --> Done[Task complete]
Skills tell it how. The CLIs give it reach. The harness runs the loop.
Everything above works when you kick it off by hand.
But the true leverage shows up when you stop being the one who presses go.
Agents can be triggered two ways beyond manual:
I've built both. Sending an email can open a pull request,[3] and GitHub issues can dispatch Codex, Claude, or Gemini. Same anatomy underneath, just with a different finger on the button.
The shape is the same for sales, ops, research, writing, or support. Don't build a platform. Pick one recurring task that eats your week, the one you could do half-asleep, and build the smallest agent that does it:
That's an agent. The rest is marketing.