How to Build an AI GTM Brain on GLM-5.2: A Signal-Based Outbound System You Run Yourself

I have run @Sortlist for ten years and watched the same pattern hold the whole time: a company goes looking for help the week something shifts inside it, a hire into a budget, a fresh round, a competitor that just beat them to a deal. Reach them that week and your reply rate sits between 15 and 25 percent. Reach them any other week and you are noise.

What follows is exactly how to build the system that catches those weeks, step by step, with the code in between. At the end I will give you the whole repo.

Get the order right first

Most outbound is built sender-first.

You buy the sending tool, load a list, start sending, and timing becomes an afterthought. That is precisely why the replies dry up.

Build it the other way.

Find the company that changed something this week, then write the message as your reaction to that change. Get the order right and you stop needing a bigger list or a rented intent feed. Every step below is that one idea, wired to run on its own.

Step 1. Put GLM-5.2 behind the brain

Start with the reasoning layer, because it is the part everything else leans on. The brain talks to its model through the Anthropic Messages API, and GLM-5.2 speaks that API natively, so it drops in with no code change. You point three environment variables at it and you are done.

What it entails in money: GLM-5.2 runs about $1.40 per million input tokens and $4.40 per million output, which at this system’s scale is a few dollars a month. Our full fleet at Sortlist, fourteen agents doing heavy research all day, runs around four hundred dollars a month. If you want zero cost, change one line, GTM_BRAIN_MODEL=glm-4.7-flash, and it runs on a free model through the same endpoint, or point the base URL at a local Ollama and nothing leaves your machine.

What good looks like. A one-line test comes back from GLM-5.2, not from Anthropic, and you are billed cents.

Where it breaks. Pasting the key into ANTHROPIC_API_KEY instead of ANTHROPIC_AUTH_TOKEN. Z.ai authenticates with a bearer token, and the wrong variable silently falls back to the offline heuristic, so your drafts come out wooden and you blame the model. It is the single most common setup mistake.

Step 2. Clone the brain and run it dry

Before you wire a single real source, run the whole loop on sample data so you can see it work. It drafts and prints, and it sends nothing.

What good looks like. The gate prints PASS, then the brain ranks a handful of accounts, drafts an opener for the hot ones, and labels every send DRAFT (dry run, nothing queued).

Where it breaks. Reaching for –live on day one. A system that can enroll on its own and drafts one confident, wrong opener will mail your whole list before a human sees it. Everything stays dry until you have read real drafts and passed the gate in step 6.

Step 3. Watch for movement, do not rent a list

The motion starts from something that moved, sorted into five buckets that are not equal in weight:

The repo ships a real, no-auth adapter that reads public job boards, so “free signals” is a working example, not a claim:

Four of these buckets you can research off the public web for free, and they carry the system well on their own.

The fifth, demand, is a different gear: a company searching for exactly what you do, before it has told a single salesperson. That one is hard to catch on the open web, which is the thing Sortlist has spent ten years watching, so you can wire it in through Sortlist whenever you want more reach. The repo runs fine without it. It just runs further with it.

The detail most people miss in the free buckets is the reposted role: the same job listed twice usually means the first hire fell through, and that company is in more pain than the one that posted once.

What good looks like. A short ranked list where an account that a fresh round and a live search both point to lands on top, each row carrying a why-now a rep could say out loud.

Where it breaks. Sensing everything and ranking nothing. Cluster and rank at the door, or the sorting problem lands on the send and it gets noisier every day.

Step 4. Let GLM-5.2 decide who gets a message

Only after a signal exists does the brain decide anything, and the deciding is the actual moat. GLM-5.2 reads the trigger, the account’s full history, and a plain description of who you want as a customer, then returns a score, a why-now that quotes the real trigger, and one play.

The reasoning lives in a plain file you can edit without touching code:

Saying no is most of the work.

A system that skips three accounts out of four is worth more than one that mails all four, because the no is where the targeting lives.

What good looks like. Hot accounts come back with a why-now you could paste straight into an email. Lukewarm ones come back as skip, with a reason.

Where it breaks. Scoring a signal without the account’s history. Strip the memory and GLM-5.2 cannot tell someone you chased twice from a stranger, so it recommends the same opener again and you read like a stalker.

Step 5. Write the opener from the trigger

Now, and only now, does anything get written. The rule is one sentence: the first line quotes the trigger back in the buyer’s own words. Never “Hi {{firstName}}”. The voice lives in another editable file:

If the message could have gone out last month unchanged, the brain skipped its own job and the draft gets thrown away. A real trigger does not need nine follow-ups to manufacture relevance, so the sequence stays short.

What good looks like. Ten drafts read back to back, all different, because the triggers are all different.

Where it breaks. Padding the sequence back to nine touches to “stay top of mind.” Length is what you reach for when the opener is weak.

Step 6. Make it grade itself before it sends

This is the part most “AI SDR” demos quietly skip, and it is the one that earns trust. Before a live send, the brain grades its own judgment against a labelled golden set, and once real outcomes exist it checks whether the accounts it scored hot actually win more than the ones it scored cold.

If it cannot prove that, it does not send.

The learn loop tunes the surface, which copy wins.

This gate grades the foundation, whether the score means anything at all. Almost everyone optimizes the surface on top of a foundation they never checked.

What good looks like. The gate runs offline and free before every send, and a miscalibrated judge gets stopped instead of let loose on your domain.

Where it breaks. Overriding the gate because the pipeline looks thin this week. The one run you skip the check is the one that mails your whole list off a target nobody verified.

Step 7. Close the loop and put it on a schedule

An agent that does not learn is a faster script. Feed every outcome back in, and the buckets that book meetings get heavier while the openers that die get cut.

Then, because the whole motion is one command, a single cron line runs it before you wake up.

What good looks like. Month one the brain weights the buckets the way you guessed. Month three it weights them the way your market actually behaves, because it spent two months marking its own homework.

Where it breaks. Logging sends but never logging outcomes. With no reply data the weights never move, and you are paying GLM-5.2 to run an expensive scheduler.

What the morning looks like now

I open my laptop to a short ranked list, each account with one line under it saying why it is there this week. I read it in two minutes and pick: send, edit, or skip. GLM-5.2 built the list and the openers overnight.

On our own pipeline this booked nineteen meetings in two weeks, a twelve percent reply rate off a hundred and forty-two signal-qualified leads. The funding signals and the first-party visits drove most of the booked calls. The lone social likes were the ones it skipped, and skipping them is why the rest landed.

A free build to understand it. max when you get serious.

Every step above ships in one repo: the five buckets, the memory store, the GLM-5.2 judge, the trigger-grounded drafting, the self-grading eval gate, and the learn loop. It is safe by default, it drafts everything and sends nothing until you say so, and it runs on a free model if you want it to.

This build is free, and it is the fastest way to actually understand signal-based outbound. Run it and you see the motion from the inside: which triggers matter, why saying no is most of the targeting, how a brain beats a faster sender. That alone is worth more than most of the tools you are renting.

Comment BRAIN and I will send you the repo.

If you are looking for a serious solution, one with the buyer-side demand built in and the whole motion run for you at scale, that is max.

The free build teaches you the system and runs it on your own tools. yourmax.ai is the version you reach for when you want it operated, with the demand data you cannot get on your own already wired in. Start free to understand it. Move to max when you want it doing the work.

**Almost everyone says they are doing AI outbound. Very few have a brain in production deciding who not to email. **That gap is the whole opportunity, and the only people closing it are the ones who run the thing instead of posting about it.

Let’s build.