WTF is Agentic AI?

There's been a lot of noise lately about "agentic AI," with everyone from startups to tech giants claiming it's the next big thing.

But what is it really?

The Reality Behind the Buzzword

Here's the thing: what people are calling "agentic AI" is mostly just connecting language models (like GPT) to do stuff in the real world. If you've ever built something that uses an AI model to make decisions and then do things like send emails, update databases, or post content - congrats, you've basically built what people are calling "agentic AI."

How Agentic AI Systems Work

Let's break down what's really happening when these systems run:

1. You give the AI a task, like "schedule a meeting with the team"
2. The AI figures out what steps it needs to take (check calendars, find a time, send invites)
3. It uses various tools to actually do these things (calendar API, email system, etc.)
4. It keeps track of what it's done and what still needs doing
5. If something goes wrong, it tries to fix it or asks for help

That's the basic version. But here's where it gets more interesting: you can split these tasks between multiple AI calls, each specialized for a different part of the job. Think of it like a team where different members have different roles:

• One handles high-level planning and strategy
• Another breaks down those plans into specific, actionable steps
• Others specialize in executing specific types of tasks
• Maybe another one checks the work and makes sure everything makes sense

The power comes from how these different parts work together. Each can be optimized for its specific job, using different approaches and even different AI models. It's like having a team of specialists instead of one person trying to do everything.

The Power of Continuous Operation

Here's where things get really wild: these systems don't have to stop after completing a single task. They can operate in continuous loops, where completing one task leads to identifying and starting the next one. Think about:

• Writing software: After implementing one feature, the system could analyze what to build next, plan it out, and start working on it
• Creating content: While writing a book, it could finish one chapter, figure out how it connects to the overall story, and then plan and write the next one
• Building products: After launching a version, it could gather feedback, identify improvements, and start working on them

It's like having a never-sleeping team that keeps pushing things forward. Each cycle through the system can:

1. Evaluate what was just completed
2. Decide what makes sense to do next
3. Plan it out
4. Execute it
5. Then start all over again

This is where these systems start to get genuinely powerful - not just completing individual tasks, but running continuous processes that build on themselves. Of course, this also makes all those challenges we talked about earlier even more important - one small error could snowball if not caught early.

Core Technical Challenges

When you dig past the marketing, there are some genuinely interesting technical challenges people are working on:

1. Making these systems actually reliable:

   • How do you stop the AI from hallucinating and sending emails with wrong information?
   • What happens when an API call fails halfway through a task?
   • How do you handle rate limits and timeouts?

2. Dealing with complex sequences:

   • How do you break down "organize a conference" into actual, concrete steps?
   • What happens when step 3 fails and steps 1 and 2 need to be rolled back?
   • How do you handle tasks that might take days or weeks to complete?

3. Managing context and memory:

   • How do you keep track of all the relevant information across multiple steps?
   • What happens when the context is too large for the AI's context window?
   • How do you store and retrieve relevant information efficiently?

Implementation at Scale

The real innovations aren't in the basic concept of connecting AI to actions - they're in making it actually work reliably at scale. Some concrete examples:

• Companies are building better ways to test these systems before deployment, like running simulations of complex tasks to find failure points
• New approaches to breaking down tasks, like having one AI instance check another's work before executing actions
• Systems for rolling back actions when things go wrong, kind of like database transactions but for real-world actions
• Methods for handling partial failures and resuming tasks from the middle instead of starting over

Unsolved Problems and Future Work

If you want to work on what actually matters in this space, here are the concrete problems that need solving:

1. Safety and verification: How do we prove these systems will do what we want and nothing else?
2. Error handling: We need better ways to deal with the messy reality of external services and APIs
3. Cost efficiency: Running language models for every step gets expensive fast - we need smarter ways to minimize AI usage
4. Testing: How do you effectively test something that might do different things each time?

What I'm building

Delegate tasks. Get software.

Give Vroni a GitHub issue, bug report, spec, or rough idea. It reads the repo, plans the change, writes code, runs checks, and works toward a review-ready pull request.

Take a look at vroni.com