A lot of people building software with AI are now setting up agentic pipelines: several AI agents chained together, each with one narrow job, passing the work down the line. I do it constantly for code. What I want to talk about here is doing it for something with no code in it at all.
I spent several days recently asking AI to find a name for the biggest project I'm building. It produced hundreds of suggestions. That part was easy. Nearly all of them were useless.
The thing I actually ended up with, though, was a process for finding the rare good one.
Why one prompt wasn't enough
I'm not going to say what the project does here. I'll say what kind of thing it is, because otherwise none of this makes much sense: it's a developer tool built around AI, it comes in several pieces, and it's bigger and more ambitious than anything else I'm building. The name has to work across all of it.
It already had a working name. A very good one, perfect in fact, right up until a major AI company decided to call their entire product lineup something almost identical. Nobody called to ask. So that name is gone.
I wanted something short, memorable, easy to say, and broad enough to carry a family of products. The main application would use the name followed by "Studio". Other parts would use "Runtime" or "API", and "CLI" for the version you type commands into. It also had to sound natural in a sentence like "Built with...".
I gave that brief to the AI. It came back with a polished list that looked plausible for about thirty seconds.
The problems became immediately obvious. To a human, anyway. Some names were impossible to spell after hearing them once. Some sounded like medicines or consulting firms. Others were already games, developer tools, AI products, fashion brands, or cryptocurrencies. A few were technically available because no human would ever want to say them.
The AI also has a deep affection for gluing two vaguely meaningful words together. That's where "Objectweather" and "Novelhorn" came from. They were original in the same way that spilling two drawers onto the floor creates an original arrangement.
Asking for another list didn't help much. The AI kept returning to the same safe patterns. Pleasant words joined together. Smooth invented words with uncertain spelling. Several that seemed to promise the advancement of humanity, which felt like a lot to ask of a developer tool. It was producing names, but it wasn't learning how I judged them.
So I stopped treating naming as one question, and turned it into an assembly line.
Six narrow jobs
The pipeline ended up with six stages. Each one had a single job and the power to throw candidates away.
The first agent invented names. It wasn't allowed to search the web or think about domains at all. Its job was variety, so I pushed it through different territories: ordinary words, invented words, playful insults, animals, old stories, human ability, cooperation, short words that suggest progress.
Keeping availability out of this stage mattered. Once the generator starts thinking about what's free, it quietly learns to prefer empty names over good ones, and I didn't want that.
The second agent judged whether a name was actually appealing. Can someone say it after reading it, and spell it after hearing it? Would I be happy putting it on a product? Does the whole family of names sound right?
This is where phrases that looked interesting in a list died as nouns. "Given That" was one of them. "Open the project in Given That" is not a sentence anybody says. "If Need Be" got through an early version of the filter, even though it sounds like software you use reluctantly. Accurate on a bad day, but not the message. I rewrote the instructions after that.
The third agent used what it already knew to spot famous products and strong associations. A quick memory check, no research: a well-known game or a major developer tool could kill a candidate before anyone spent an hour looking into it.
The fourth agent searched the live web. It looked for the exact name, close spellings, names that sound the same out loud, and combinations with words like Studio and Runtime. It also had to judge distance. An unrelated drink with the same name was friction. An AI development product with the same name was a fatal collision.
"Calm Riot" and "Bold Whisper" are why this stage needed more than an exact-name search. Both are clear and easy to remember. Both also contain a word tied to an enormous product in games or AI. The full names might be legally different, but people would still think of the bigger thing first.
The fifth agent checked the practical places the name has to live. Domains counted, though an unavailable dot-com was never an automatic no. A good Studio domain could be enough. Software package names and public code accounts got the same treatment: an abandoned package is a nuisance, while a live developer tool using the exact command is a real collision.
One candidate cleared the web search and then died here, because a newly published code-intelligence tool had taken the exact name. It was tiny. It also did almost the same job for almost the same people, and being small doesn't stop anyone from getting confused.
The sixth agent did a first-pass trademark check in the United States and Europe, looking for exact and similar marks in software, entertainment, and online services. This is only a filter to run before paying a trademark lawyer. It can find an obvious reason to stop. It can't tell you a name is safe, and it sounds equally certain either way.
Most candidates were long gone before stage six.
Keeping the line moving
At first the agents ran one after another, and it was painfully slow, because most batches ended with nothing left at all. While the second agent judged the first batch, the generator sat there doing nothing, which is a strange thing to let a tireless machine do.
So I changed it so several batches could move at once. One group being judged for sound and appeal, another being generated, a third out doing web research. Later I ran two generators side by side, because generation had become the slowest part.
When a candidate finally survived every stage, new generation stopped, but everything already in the pipeline ran to the end. Otherwise the first acceptable name wins purely by arriving first.
That created new problems. Searches would stall. An agent would stop with its checks half done. Two generators would propose the same name within minutes of each other. Going faster only helped if I could see the state of every candidate.
The fix was a plain text ledger. Every name that got generated went into it, with its latest result and the reason it failed. New generators read that file before proposing anything. They didn't need the whole history in memory, only an answer to whether a word was already there.
The rejected list stopped the AI from serving me an old failure as a fresh idea. It also let me go back and reopen decisions when the rules changed.
The rules kept changing
The early collision checks were far too strict. A name could fail because a small company used it for something unrelated, or because the dot-com was registered. That gave me names that were easy to register and impossible to love.
So I loosened them. Category and size started to count. An old, small software library lowered a score instead of ending the name. A cryptocurrency in a distant market became a note. A major game studio, a live AI platform, or a developer command with the same name stayed a hard stop.
Pronunciation went the other way. One invented name, "Asmeant", looked perfectly readable to me and sailed through the agents. Then I said it to a few people. Too many of them heard "Asment", and would have gone looking for the wrong spelling.
It had survived web research and a legal check, and then died in an ordinary conversation. Say the name out loud, then ask someone to write it down. After Asmeant, that became one of the tests I cared about most.
I also caught the pipeline rewarding respectable names over memorable ones. The agents were becoming experts at finding words that survive. Survival is not affection. A harmless name nobody loves is still a bad name.
So the final scoreboard gives half its score to whether I like the name at all: how it sounds, what it suggests, how short it is, whether I'd enjoy saying it every day. A little over a third goes to collision risk. The rest goes to whether the domains and accounts are workable. A direct conflict can still delete a name whatever its score.
Taste doesn't fit in a prompt
No brief captured my preferences in one go. I liked short names more than the early results suggested. I was fine with playful negativity, if it could become a mascot or a joke. I disliked words that sound impressive and are awkward to say. I cared what the name did inside a sentence, not how it looked in a list.
The useful moments were all small corrections. I'd explain why one name beat another. The AI would update the brief for the next round of generation, and sometimes the screening rules too. Every so often it would come back and ask me to choose between a few very different candidates, or to say what I liked about one.
None of that handed my taste over permanently. It made the next round better. The process needed correcting constantly, because each agent was extremely good at following whatever rule it was given, including the rules that were slightly wrong.
A different kind of AI work
I still haven't let the pipeline pick the name. It can't. Naming ends in taste, and the taste has to be mine.
What it did was make a big, messy search manageable. It went in more directions than I'd have thought of alone. It remembered every rejection. It checked thousands of small facts, sorted the serious conflicts from the irrelevant ones, and wrote down a reason for each.
That's quite different from asking AI for an answer. I gave several agents one narrow job each, watched where the process broke, and rebuilt it while it was running. What came out was better than a list of words. It was a short set of choices I could make without wondering which obvious problem I'd missed.
So what's the name?
I'm not telling you yet. Soon, along with the project it belongs to. I think both are worth the wait.