Same model, same prompt, same buying signal. Different context, and the message comes out completely different. This is the context, laid out as files an agent reads.
The manual version you run yourself. The fully managed one is max.
Everyone tuning an outbound agent is tuning the prompt: sound more human, add a rule, forbid a cliché. It works for a week, the replies flatten, and people blame the model. The model was never the ceiling. The context was.
Context engineering is deciding what your agent can see before it writes a word: who this person is, what they just did, what you are actually allowed to claim, and how you sound. This pack is that context, laid out as plain files, plus three Claude Code skills that build a window, write from it, and sharpen it over time, and a runnable reference engine so you can watch the whole loop before you wire in anything of your own.
A prompt is what you tell the model to do.
Context is what it can see while it does it.
Most of what people call hallucination is really an empty window.
- Prompts vs context
- The four layers of a context window
- How the loop runs
- The three skills
- What is in here
- Prerequisites
- Quickstart in Claude Code
- See the whole loop in 30 seconds, no API key
- Make the context yours
- The one rule
- Manual pack vs max
- Who built this
- Contributing
- License
A prompt is what you tell the model to do. Context is what it can see while it does it. Most of what people call hallucination is really an empty window.
The model invented a figure because the real one was never put in front of it. It sounded like a robot because nothing showed it how you write. It pitched the wrong thing because it could not see the two emails you already sent that account. None of that is reachable from the prompt. You fix it by engineering the window: deciding, for each step the model takes, what it needs to see and, just as much, what to keep out of view.
Every window an outbound step needs carries four things and no more.
| Layer | What it is | Miss it and |
|---|---|---|
| Role | The one job of this step (write a first line, score an account), never "run outbound". | the model does the whole job badly at once. |
| Case | This one company, this one person, the signal that fired this week, and what it means. | it writes to a segment, a template with a merge field. |
| Evidence | The account's own history plus the only proof the agent is allowed to quote. | it invents a number that does not exist. |
| Rules | How it must sound, the output shape, and the hard stops: no pricing, no unverified claim, no auto-send. | it sends something you would never have signed. |
Evidence is the layer that stops hallucination, because a fact that is not in it is a fact the model may not use.
flowchart TD
DAY["a day of activity<br/>funding · job · company · social"] --> EXTRACT["extract the real signals"]
EXTRACT --> ASSEMBLE["1 · assemble<br/>the smallest sufficient window"]
ASSEMBLE --> WIN
subgraph WIN["the context window · four layers"]
direction LR
ROLE["Role"] --- CASE["Case"] --- EVID["Evidence"] --- RULES["Rules"]
end
WIN --> WRITE["2 · write<br/>one grounded message,<br/>or it blocks"]
WRITE --> CHECK["skeptic check<br/>no claim outside Evidence"]
CHECK --> LIST["ranked shortlist<br/>a human says yes"]
LIST --> REFINE["3 · refine · weekly<br/>write the lesson back<br/>into the files"]
REFINE -.->|"the next window is sharper"| ASSEMBLE
A nightly job assembles a fresh window for each step in turn: one to extract the real signals out of the day's activity, one to score who has earned a message and why, one to write the first line, and one to check that draft as a skeptic before it goes anywhere. Refine runs weekly over the outcomes. The output is a ranked shortlist with a reason beside each name, and the reason quotes the actual trigger.
Three Claude Code skills work the four layers. They live in .claude/skills/ and Claude Code discovers them on its own the moment the folder is in a project you open.
| Skill | Folder | What it does |
|---|---|---|
| 1 · assemble | .claude/skills/assemble-context/ |
Builds the smallest sufficient window from the four layers for one account and one signal. Loads only the relevant slice, never the whole knowledge base, because a bloated window writes generic copy. |
| 2 · write | .claude/skills/write-from-signal/ |
Turns that window into one grounded message. Opens on the signal, uses only proof that sits in Evidence, and blocks instead of inventing when a fact is missing. |
| 3 · refine | .claude/skills/refine-context/ |
After a batch of replies (or the silence) comes back, rewrites the context files so the next window is sharper. This is the step almost everyone skips, and it is the whole moat. |
.claude/skills/ three drop-in Claude Code skills (auto-discovered)
assemble-context/ build the smallest sufficient window from the four layers
write-from-signal/ turn that window into one grounded message
refine-context/ after replies land, rewrite the files so the next window is sharper
context/ your four layers, as plain files you edit
icp.md fit as a situation, with A/B/C tiers and an anti-ICP (Case gate)
signals.md a real signal taxonomy: how to READ each signal, not detect it (Case)
offer.md the offer, the proof table, value props by situation, objections (Evidence)
voice.md register, hard bans, the opener test, worked examples (Rules)
accounts/ one memory file per account, so the agent never repeats itself (Evidence)
engine/ a runnable reference: the same skills as code
pipeline.py extract -> score -> write -> check -> refine, on sample activity
kit.py assemble.py steps.py model.py the pieces, small and readable
example_activity.json a day of raw activity to run on
examples/sample-run.md the output you should expect
LICENSE MIT
The context/signals.md and context/offer.md files are the ones worth your time. The signal taxonomy (how to read a raise, a new leader, a tool switch, and what each one changes in the message) is the part no vendor can ship you, because it depends on your offer.
| What | Check / get it | |
|---|---|---|
| 1 | Claude Code | The three skills auto-discover once .claude/skills/ is in a project. |
| 2 | Python 3.10 or newer | python3 --version. Only the reference engine in engine/ needs it. |
| 3 | A model key | Optional. The offline demo needs none. To run the engine against a real model, set MODEL_API_KEY (any OpenAI-compatible endpoint) and pip install openai. |
About ten minutes.
- Drop it in. Clone this repo into a project you open with Claude Code, or copy
.claude/skills/andcontext/into an existing one. The three skills auto-discover. - Make the context yours. Edit the files in
context/. Start withsignals.md(how you read each buying signal) andoffer.md(what you are allowed to claim). They ship filled with a worked B2B-SaaS example, so you are editing, not staring at a blank page. This is the only real work, and it is the whole point. - Run the loop by hand on one real prospect:
- "assemble the context window for
<account>on the<signal>it just fired" - "write from that window"
- after replies come back: "refine the context from this batch of outcomes"
- "assemble the context window for
- Wire it into your own loop (schedule, CRM, inbox) once the messages are good by hand.
python engine/pipeline.pyReads a day of sample activity, extracts real signals, assembles a fresh window per step, and prints a ranked shortlist of drafted messages plus the accounts it skipped (the gate working). Then it runs one refine pass. What you should see:
[75] Northwind | why now: Northwind posted a job: Growth Ops Manager
Saw the Growth Ops role went up right after you stepped in. Usually that hire
spends month one firefighting attribution instead of building, so we take that
half off the plate for teams your size. Worth a look, or too early?
Nothing is sent. Point it at any OpenAI-compatible model by setting MODEL_API_KEY; leave it unset and a deterministic stub runs, so it works offline. See examples/sample-run.md for the full expected output.
Four files and a folder. Plain text, edit without touching Python.
context/icp.md- fit as a situation, with A/B/C tiers and an anti-ICP. Vague ICP in, vague scoring out.context/signals.md- the signal taxonomy: for each signal, what itmeans, what itdoes not mean, what itchangesin the message, itsdecay, and itsstrength. The highest-leverage file here.context/offer.md- the offer, the proof table, value props by situation, the objections. The only place a claim is allowed to come from.context/voice.md- register, the hard bans, the opener test, worked examples.context/accounts/- one memory file per account, so the agent never reopens a dead angle or repeats a line.
If a fact is not in the context files, the agent may not use it. No invented numbers, no borrowed proof, no confident guess. A fluent, wrong message costs more than no message. The files are the guardrail, and the check step in engine/ enforces it.
The pack gives you the method, and doing the four layers by hand is the point: it is how you learn what your own context should say. max is the agent we built at Sortlist on exactly this shape, and it runs the loop for you.
| This pack (manual, you run it) | max (fully managed) | |
|---|---|---|
| Assemble | you compose each window from the four files | assembles a window per signal automatically |
| Signals | your own reads, in signals.md |
watches job, funding, tool-switch and buyer-side demand for you |
| Write | one message by hand, or in Claude Code | drafts with the real reason attached, waits for your approval before anything sends |
| Refine | you run the weekly pass | runs it every batch, the context keeps sharpening on its own |
| Setup | clone it, an afternoon | connect your tools, describe the routine in chat |
| Cost | free, MIT | paid, in limited demos now |
If the manual version is enough for you, use the manual version. When you want it running without you assembling every window, that is max.
Nicolas Finet, co-founder and CEO of Sortlist. Four of us started Sortlist in Brussels in 2014; it now runs 4,000+ paying agencies. Sortlist owns Overloop AI, the outbound engine, and builds max, our AI growth agent. I have run signal-based outbound on the marketplace for ten years.
I like to build. This is the manual version of the context we actually run, put together so you can clone it and feel the difference between prompting a model and engineering what it sees. The full version is max.
Found a weak signal read, a proof mapping that misfires, or a layer worth adding? Open an issue or send a PR. This gets sharper when the people running it push back on it.
MIT. Take it, gut it, make it yours.