When Bryan first said we were going to build an agent, my first reaction wasn't excitement, but total intimidation. We spend our days designing the workflows AI agents run on for customers, but building our own feels different. I knew I needed to understand it, but I wasn't sure where someone in operations fit.
*cue the catalyst*
My brain doesn’t always lead with understanding highly technical pieces, and I’ve always relied on Ben to build the system, while Bryan designs the architecture. So when they started talking about me building an agent, retrieval, context, and pipelines, I honestly wasn't sure where I fit into any of it.
Ben kept saying we just had to “jump in” - oOoOff! Sure, but where?!
So I put on my boots and I started with… “well, what do I want this thing to do?” We started with a spec that highlighted every piece of context we felt was relevant and how Sol touched it.
If I'm honest, I expected to spend most of the effort watching the technical guy do technical things while I waited for them to tell me what they needed. That felt like the natural role for someone like me.
Low and behold, I couldn't have been more wrong.
Getting Started With Agents
The first week was painfully slow. Ben and I chipped away at getting Sol set up, and every little piece felt like it took forever. It wasn't that we weren't making progress. We were, but It just didn't feel like progress because there was nothing to point at and say, "Look what we built."
In that first week, what we did accomplish was a vision of Sol.. a sun goddess (or Medusa look alike), you decide.
At the same time, Bryan kept reminding us that Sol wasn't creating value yet and he wasn't wrong. I knew she wasn't. But every time he said it, I found myself asking the same question over and over again:
"Okay... but what do I do?"
That was the hardest part.
I kept defaulting to the idea that my biggest limitation was simply not knowing enough. I assumed there were answers sitting somewhere inside Ben's or Bryan's heads that I just couldn't access because I didn't speak the language. Looking back, I don't think that was actually the problem.
It took an uncomfortable conversation for us to realize we weren't disagreeing, but we were simply looking at the same problem from different places.
Bryan could see where Sol was eventually going. Ben could see how the system worked underneath. I was trying to figure out what I could do on Monday morning that would actually move us closer to that vision.
Those are three completely different perspectives.
Eventually, the path became surprisingly simple. I would help define the content structures, Ben would build the mechanism behind them and Bryan would keep connecting the work back to the bigger picture.
One sentence and it took us most of an afternoon to get there. But that afternoon changed how I thought about building agents. I used to think the difficult part would be technology and now I think the difficult part is making sure three people are solving the same problem. (IYKYK)
One of the first moments where everything started to click for me was Radar.
We finally reached the point where Sol could monitor what Radar was collecting, summarize it, and even suggest people in our network we should talk to based on the information she was seeing.
A few lessons from the messy middle:
- Progress feels slower than it actually is.
- Team alignment beats technical brilliance
- Trust your gut on access and security
- Build loops, not prompts.
Taking Agents From Useless to Useful
From the outside, that probably doesn't sound like much but inside our team, it felt enormous. It was the first time I looked at Sol and thought, Oh... I can actually see where this becomes useful.
That feeling matters more than I expected. Small wins become proof that you're building the right thing, even if you're still miles away from the finished version.
Then we ran into Dropbox *screaaams*. We wanted Sol to access our transcript archive, and technically there was an obvious answer: give the application access to the account.
Except our Dropbox isn't just transcripts. It's banking information, client work, employee documents.
The operational side of my brain immediately went into protection mode and I said no.
Not because I didn't believe in what we were building, but because protecting that information is literally part of my job. What surprised me was how uncomfortable it felt to be the person saying no. Nobody likes feeling like they're slowing down progress, especially when everyone is excited about what's possible.
Bryan immediately backed the decision.
Instead of treating it like I'd blocked the project, we treated it like we'd uncovered a better problem to solve.
That moment has stayed with me because it reminded me that building an agent also involves a layer of trust. Every useful agent wants more information than you're comfortable giving it and someone has to decide where the line is.
The Goal is to Build Agent Loops
Lately I've also started thinking differently about prompting. When we first started, I thought prompts were the work. Now I'm beginning to understand that prompts are just the beginning and the real goal is building loops.
Instead of asking the same question over and over again, the system keeps learning, organizing, and improving in the background. The outputs become better because they're built on everything that came before them.
Somewhere along the way, I stopped thinking about Sol as a project with a finish line. At the beginning, I kept waiting for the moment we'd "build the agent." The moment where we'd check the box and say, Okay, she's done.
That moment doesn't exist.
Every time Sol learns something new, we realize there's another question we haven't answered. Another workflow we haven't thought through. Another decision about trust, process, or judgment that still belongs to us.
Where This Goes Next
The funny part is that Sol isn't the only thing evolving but seems I am too.
A few months ago, I thought my job was to wait for the technical people to tell me what they needed and now I feel like I can rub elbows with a little more swagger. You don't finish an agent because the business around it doesn't stop changing. The people using it don't stop learning. The work doesn't stop evolving.
The agent grows with the company.
And if you're doing it right, the company grows with the agent. And to leave you with something valuable, I think in this process, it's important to highlight a few skills that matter more than coding:
- Getting your team aligned
- Knowing what information to trust
- Breaking big ideas into repeatable workflows
- Deciding where humans should stay involved
- Improving the system a little every week
Keep us posted on your progress.
