Everyone is building agents right now. Open a tech newsletter, scroll a dev forum, sit in on a
standup at almost any company shipping software, and the word agent shows up somewhere. It doesn't just mean a chatbot or a script anymore. It means software that takes a goal, breaks it
into steps, calls tools, checks its own work, and keeps going without a human clicking "next"
at every stage.
The tooling around this has grown just as fast. LangChain turned "build an agent" into its own
small industry of abstractions. Strands, from AWS, came in with a cleaner, more opinionated
take. n8n let you wire one up by dragging boxes on a canvas, no code required. There are dozens
more: some built for research, some for production, a few that seem to exist mainly so their
creators had something to build.
I spent time in most of them, though most of that time went to LangChain. Not as a critic
hunting for reasons to walk away, but as someone trying to actually get something running, the
way you'd try on a few pairs of shoes before a long walk. The more time I spent, the more I
came around to one idea: building an agent isn't really building a system. It doesn't need to
be coded from scratch and shipped like one. It's simpler than that, and a lot simpler than the
system-design work everyone treats it as.
This is the story of how I built agenta. You configure it. You don't build it.
The era of local AI models: Ollama, LM Studio
A few years ago, running a model locally wasn't really an option for most people. It was
expensive: you needed hardware that cost real money, high-performance GPUs sitting in your
house. And even if you had the rig, the models themselves weren't great. Open source was thin,
a handful of checkpoints, mostly undercooked next to whatever OpenAI or Anthropic had behind an API. So most people just didn't bother. Why fight a local setup for a worse model when a cloud
API gave you a better one in five minutes?
Then Ollama came along and turned all of that into one command. ollama pull, ollama run, and a minute later you're talking to a real model in your terminal. No CUDA to install, no forum
thread at 1am trying to figure out why your build won't compile. LM Studio did the same thing
for people who'd rather click than type: pick a model, hit run, chat. You didn't even need
serious hardware to make it worth doing, either. A basic Mac Mini, no discrete GPU in sight,
could run a capable SLM at usable speed, because Apple's unified memory did the heavy lifting
Ollama needed. Neither tool invented local AI, they just took the hard part off, and that's a
bigger deal than it sounds. Once running a model locally stopped being a skill you had to earn
and became just... an install, local-first stopped being something you settled for. It became
something you'd actually choose, even with a cloud API key sitting right there.
That's the first part of why I built agenta: it talks to Ollama out of the box instead of
assuming you've got an OpenAI key ready. By the time I got around to building it, the model
wasn't the hard part anymore. Everything around it still was. This is an era where anyone can
run a decent model on their own hardware.
Common misunderstanding in working with AI agents
Here's the misunderstanding I kept seeing, in myself and in almost every write-up I read:
treating an agent like a piece of software you write, instead of a set of instructions you
configure. People reach for code first, not because code is wrong (it's often a genuinely good
choice), but because that's the instinct software engineers default to. If it needs to work
reliably, it needs to be built, and building means code.
That instinct comes from a misunderstanding of what actually makes an agent work. An agent
isn't smart because of the orchestration logic wrapped around it. It's capable because of the
model behind it, the tools it's allowed to call, and how precisely its instructions are scoped.
Stack a thousand lines of Python around a vague prompt and you don't get a better agent. You
get the same fragile one, just with more places to break and fewer places to actually fix it.
I'm not saying code is bad. Some agents genuinely need it, custom tools, edge cases, logic no prompt can express clearly. But most agents people are trying to ship don't need any of that. They need a good prompt, the right tools, and a way to run reliably. Somewhere along the way, "build an agent" quietly became "write a program that happens to call an LLM" and that's the misunderstanding this whole project pushes back on. However, to be fair, I'm not blind to the upside of code-heavy agents more reliable in production, easier to scale, easier to test the way you'd test any other piece of software. I see it. Cut me some slack here 😂.
I fell in love with how infra command works
For context, I built agenta to run an agent the way you'd run a kubectl command. One command gives you a working bare agent, ready to accept requests.
agenta create \ --name assistant \ --model qwen3:latest \ --prompt "You are a concise, helpful assistant."
There's a specific feeling in typing a command and having it just... work. No code to write
first, no staging environment to test against, no release notes, no deploy window to wait for,
no prod rollout to watch nervously while you refresh a dashboard. You type the command, and it
runs. That's the whole story.
Most software doesn't work that way, and for good reason: write the code, get it reviewed,
merge it, deploy to staging, test it again, wait for the release, deploy to prod, watch the
logs for anything on fire. Every step makes sense on its own.
Infra never worked like that. You don't deploy a database; you point at a config and start it.
You don't release a cron job; you define it, and it runs the next time the schedule lines up.
No ceremony standing between the command and the thing actually happening. That's the mental model I wanted for agents too: not something you ship, but something you just run.
That’s the “why” and I think that’s plenty enough for a short piece
To recap: I spent enough time in frameworks to realize a good agent isn't a system you build.
It's a definition you hand off. Local models got good enough and cheap enough that "run it on
your own machine" stopped being a compromise. And somewhere in all of that, I fell for the idea
that agents should work like infrastructure: you define them, you run them, you don't ship
them. agenta is what happened when I stopped complaining about that gap and just built the
thing that closed it.
What I haven't told you yet is how it actually works under the hood, what it can really do once
it's running, or who I think it's actually for. That's because "self-hosted agent runtime"
means very different things to a solo builder tinkering on a Mac Mini versus a team running a
fleet of agents against production data. That's part 2.
Happy agenta-ing. 😄
Written with love by Arif Mustaffa
Back to blog page