Last Week the Tool Fought Me. This Week, Four Questions Built the Agent.New post

Dear Negotiation Explorer,

Last week I showed you the honest version of building a negotiation workflow in Microsoft Copilot Studio. It worked, but it fought me the whole way — the visual builder dropped steps, uploaded files arrived as code, and every agent was capped at 8,000 characters of instructions, so I was always cutting things to fit.

This week, the other end of the scale. Same goal — a working negotiation agent, built without code — but a tool that stays out of the way. It's called Cassidy, and it's what my course uses to teach agent building. This week my cohort is doing exactly what I'm about to walk you through.

Before settling on it, I tried building agents in a handful of platforms — n8n, LangChain, Microsoft Foundry, Copilot Studio. Each one, sooner or later, asked me to debug something or bring in a developer. For someone working no-code, Cassidy has been the simplest way to build and deploy an agent. Here's why — and where it stops short.

In Cassidy you build with what it calls a co-pilot — a guided wizard. You don't write code, and you don't start from a blank instruction sheet. You type one plain line describing what you want. I typed:

The co-pilot reads the context it can find — my organization, the knowledge base already loaded — and asks four questions:

I answered each in plain words. A minute later I had a complete agent: a name, a full set of instructions, and a connection to the negotiation knowledge base. Not a skeleton — a working tool.

This is the part that matters, because "easy" is only worth something if the result is good.

The agent doesn't write a generic summary. It first asks the user about the negotiation — what's being bought or sold, who the counterpart is, the key issues, the walk-away point, the relationship. Then it produces a structured preparation brief with eleven sections: the situation, the interests on both sides, BATNA and reservation value, a stakeholder map, a power and leverage read, where value can be created, an opening and anchoring strategy, a concession plan, scenario planning, the psychological factors at play, and a one-page summary to carry into the room.

And it draws on both halves of real negotiation expertise — the mechanics (interests, BATNA, anchoring, concessions) and the people (framing, trust, emotions, bias, influence) — because the instructions tell it to. That is a serious piece of preparation, produced by an agent I built in a few minutes, in plain language.

That is the leap worth seeing. Week one of my course is about using AI well — talking to it, giving it the right context. This is the step after: building a tool that does the work without you in the room. Anyone on a team can open it and get a real brief. That's the difference between knowing how to use AI and owning a tool built around your expertise.

Here's the part I find most useful, and it's easy to miss.

Those four questions aren't arbitrary. They map exactly onto how a good instruction is written: who it's for, what it produces and in what shape, what it's allowed to handle, and what knowledge it draws on. The co-pilot isn't doing something you couldn't. It's asking you the right questions and writing your answers down in a form the agent can use.

So the skill here isn't technical. It's the thinking you already do when you prepare a negotiation — who's involved, what I want out of it, what's in scope, what I know. The platform handles the machinery; you bring the judgment. That's why it can be easy and genuinely powerful at the same time: the hard part was never the software.

I said I'd be straight, so here's the honest measure of it.

If you've never built an agent before, this is an excellent place to begin, and the result is genuinely good. But it's a starting point, not a finished tool — call it sixty percent of an agent. The co-pilot writes solid instructions, but they're its format and its choices, not yours. And it leaves one thing out: a self-check, the simple green, yellow, or red where the agent grades its own brief before it reaches you. The co-pilot doesn't add that on its own.

The other forty percent is the part that makes the agent yours — writing your own instructions, in your own format, tuned to how you actually think about a negotiation. That's what turns a capable generic agent into one you trust on a live deal, and it's exactly what we build in the coming weeks of the course.

But don't lose the headline in the caveat. A few years ago, none of this was within reach of someone who doesn't write code. Today, four questions and a few minutes give a non-developer a genuinely useful negotiation agent. The starting line has moved a long way — and from sixty percent, the rest is judgment, not engineering.

If you've held off building your own agent because it sounded technical, this is the part to hear: it isn't. The thinking is negotiation thinking. The tool does the rest. You could build a first version of a preparation agent this week, in an afternoon, and feel the difference between using AI and building with it.

This is exactly what my current cohort is building right now — the same agent, the same four questions, in Cassidy. The next cohort runs in September. I'll open the details here first, so if you'd like to build your own alongside a group, this newsletter is where you'll hear it.

And if you'd rather start on your own today, my free tool — The Augmented Negotiator's Brief — gives you a one-page strategic brief for any negotiation you're walking into, ready to drop into ChatGPT, Claude, or Copilot.

If building an agent took four questions and an afternoon, which part of your negotiation work would you hand to it first — the preparation, the counterpart read, the debrief?

Reply and tell me. I read every response.