Making my Own Agent, Part 1: The what and why

I've been building my own agent harness for a few months and figured it was time to write about it. I don't have all the answers, but I learned a lot from other people's process posts and wanted to add to that pile. This is part one. 

The foundation:

You've probably heard the word agentic before, maybe a bit too much since it's sold as a marketing term. Agentic workflows, agentic coding, agentic hotel booking, agentic breathing. With as much hype as it's getting you would expect it to cure cancer and maybe one day it will but as of right now it's not creating any cures for cancer. So what separates agents and a chat application like ChatGPT? Well if you ask someone that today, the line is getting thinner and thinner. But a chat application is exactly what it sounds like where you chat back and forth with the LLM. With an agent you give it hands and fingers stretching out into the world to gather information and take actions. This can be anything from a function that gets the current date and time to a function that sends an email on behalf of the user. 

 

Okay with that in mind I set out on a trek to understand the inner workings of how an agent works. I found a tutorial from Thorsten Ball of amp code, and it was very insightful. I don't want to recount everything he said in that blog post but I do want to highlight that he shows how easy it is to make an agent in only 400 lines of Go code — maybe less if you optimize a little. It is all very readable on the most basic level. And nowadays, models are designed to be agentic. That reminds me of a discussion I had with a few people in a local Slack group. I remember part of where we discussed how, ultimately, an LLM nowadays is an agent — you give it some tools and they just call it. It doesn't take that much work. Seriously, you give it a function like this:


var ReadFileDefinition = ToolDefinition{
    Name:        "read_file",
    Description: "Read the contents of a given relative file path. Use this when you want to see what's inside a file.",
    InputSchema: ReadFileInputSchema,
    Function:    ReadFile,
}

and to actually call it: 



conversation := []anthropic.MessageParam{
    anthropic.NewUserMessage(anthropic.NewTextBlock("What's in main.go?")),
}

message, err := client.Messages.New(ctx, anthropic.MessageNewParams{
    Model:     anthropic.ModelClaude3_7SonnetLatest,
    MaxTokens: int64(1024),
    Messages:  conversation,
    Tools: []anthropic.ToolUnionParam{
        {
            OfTool: &anthropic.ToolParam{
                Name:        ReadFileDefinition.Name,
                Description: anthropic.String(ReadFileDefinition.Description),
                InputSchema: ReadFileDefinition.InputSchema,
            },
        },
    },
})

And the model calls it when it's appropriate. The things you do have to worry about are first the logic of the tool — is it going to the right API to get the weather — and the description and JSON input schema. How does an agent know when to call a tool? You load the description and input schema when the model or agent starts up, and as it's working through whatever it's working on, it knows in its context: hey, these are the tools you have access to. And let's say you want to get the weather — it knows it has access to the getWeather tool, and that it needs to input a ZIP code.

 

What I am doing

A lot of agents have been done 100 times over with minor differences, some use Go, others use Rust, some are meant for agentic coding while others are meant for executive work, so I questioned what can I do that's different and actually useful to me? At first I kept building a coding agent and it truly made me appreciate the thought and engineering that goes behind these harnesses. By harness I mean the scaffolding around the model: the loop, the tools, the prompting logic. The glue that makes it useful. For example, did you know by optimizing the way an agent reads and edits a file it can increase the edit tool call success rate by anywhere from just below 10% to over 50% improvement? These types of experiments and learnings are why I like building my own agent harness. The boring troubleshooting, the checklist stuff — I'd rather have an agent handle that so I can spend more time building tools and working with other teams on harder problems.

Knowing all of the code agents out in the open, I didn't want to create yet another — especially since the current agents are good enough and better than what I believe I can create. I decided to go down the rabbit hole of doing an AI-assisted troubleshooter or, as some companies are calling it, "AI SRE". There are many reasons why I chose to go down this path. Right now we spend a lot of time doing support for things that are easy to diagnose but the time it takes across multiple investigations really adds up. Even if the agent can't find the exact problem it can eliminate a few possible causes. Another thing a troubleshooting agent allows for is being able to have an extra set of hands — you can look at the p0/p1 issue while the agent looks at the p2/p3 issues. And there doesn't seem to be a good open-source one, at least when I started building mine in December of 2025. Sure, you had a few companies building one as their offering and since then you have cloud providers like AWS and Google Cloud creating one for their cloud, so you can't be cloud agnostic. Getting locked into one provider's implementation of something I want to own didn't sit right with me.

So am I building my replacement? I don't believe so. I think I'm building a teammate or coworker who can help when things get dire. In my limited time that I've been using the agent it hasn't always worked — sometimes it churns through tokens going the wrong direction. This of course can be optimized through the harness and various techniques but I don't think these quirks can be completely removed. 

 

What's Next? 

In upcoming articles I'll talk about what I've learned, experiments I've conducted, and other learnings. For example, in the future I have plans to allow the harness to be multi-model and even potentially from different providers. Other things I plan on writing about are optimizations to help not only improve the harness but also optimize the cost.  

If you're working on something like this or have a good use case for it, let me know in the comments.

 

Location: Utah, USA

Comments

Post a Comment

Popular posts from this blog

Beyond Static Logging: Introducing Dynamic Log Levels in Go

 This is part one of a multi-part series that I go into making a dynamic logger that allows you to change the level during runtime.  Before exploring how to develop a dynamic logger, let's examine the fundamentals of logging and the use of Enum-like types by many common logging systems. Let's take the standard slog library for example, This is their current logging levels:   const ( LevelDebug Level = -4 LevelInfo Level = 0 LevelWarn Level = 4 LevelError Level = 8 ) The code snippet above illustrates how each logging level is assigned an integer value. This arrangement facilitates navigating between log levels without jumping directly from, say, error to debug. Instead, you can increment or decrement through the levels progressively by setting the desired level in a loop. LevelVar For those familiar with Go and its concurrency model, managing logging levels across goroutines can present challenges, potentially leading to inconsistent l...
Read more

My website Services stack.

Image
  Table of contents The code Server stack Data Management     Mysql      Sessions     Deployment Secrets Load Balancing     Traefik      Cert-Manager Introduction   I n this post I will talk about the services that are running my sites along with reasoning behind each. Similar to my website infrastructure post I will not be doing any How-Tos but format it as a birds-eye view of how my stack is implemented. The Code     Most of my dynamic code is written in PHP, from my registration/Social site to my contact form. It's a well tested language which made it a very good language to learn and program with. In addition  many frameworks and libraries are written in php and let's not forget some of the biggest platforms in the history of the web are created using PHP like WordPress, Shopify, and Facebook (HHVM).   Although php is a great and powerful language, I plan on moving to Node...
Read more

How we sped up a Postgresql procedure 50X

Image
  Introduction   What I'm about to explain may seem rudimentary to a DBA but it was over looked by our distinguished engineer. And once you learn the inner workings it's a "duh" kinda moment where you look back and wonder why you didn't see it. What is a Postgres procedure   Let's start with the basics. There are postgresql functions and procedures. The major differences between the two is that functions returns a result while a procedure does not. In addition to the return differences, you Select a function but Call a procedure.   Diving into the specifics, a function is almost like a function in any other programming language. It takes inputs and can manipulate it or use it in a sql statement.     Adding two numbers that are fed as inputs: 1 2 3 4 5 6 7 CREATE FUNCTION add_numbers (first_number integer , second_number integer ) RETURNS integer LANGUAGE SQL IMMUTABLE AS $$ SELECT $ 1 + $ 2 ; $$ ;   Taking two inputs a...
Read more