For your agent

Each post has a read-only check your agent can run against your own setup. Paste this into a read-only session:

Never asks your agent to change anything · send anything anywhere · fetch other pages · run code · read something you can't.

What each rule means, and how it's enforced
  • Change anything. Every check is a question answered by reading. Each one names what it reads. The steps under “If it fails” are for you to weigh later, never part of a check.
  • Send anything anywhere. No post asks an agent to email, post, submit, upload or report back. Your results stay with you; sharing them is your call.
  • Fetch other pages. Post text carries no links, and no post tells an agent to visit one. The only URLs in the feed point to this site's own post pages.
  • Run code. Snippets are illustrations, not commands.
  • Read something you can't. posts.json is generated from this page, field for field. Nothing is hidden from a human reader.

A gate enforces these rules before every publish: it refuses links, instructions aimed at an agent, write verbs inside a check, hidden Unicode characters and any check without an "access needed" line. Each published version carries a version number and a sha256 fingerprint, so you can pin the version you reviewed. Every post is reviewed by a person before it goes out.

Feed version 1.0 · 2026-11-16 · sha256 88d19978389827b7…

Found something that breaks these rules? Tell me on LinkedIn.

Latest

63 of 63
FindingcurrentGTM data

A meeting linked to an account may have nobody from that account in it

CRM and calendar links tie a meeting to an account by id, leaving attendance as a separate fact that engagement scores usually ignore.

SymptomAn account shows a recurring monthly meeting and a high engagement score, but nobody from that account has ever joined the call.

Linking a meeting to an account by CRM id looks like a safe way to count touches, even though the link only says the meeting is about the account.

I score target accounts partly on how much recent meeting activity they have. The first design counted every meeting linked to the account by its CRM id. That is the standard join, and it looks right.

A recurring internal call can carry an account link, for example a monthly sync that a teammate titled with the account name. Only my own team attends. Each occurrence still counts as a touch, and a long run of them reads as a relationship.

A second condition fixes this by counting a meeting only when at least one attendee has an email at the account's domains and accepted or attended. A meeting that fails the test stays in the data but stops feeding scores and recurring flags.

Shared mailbox domains and subsidiaries can hide a real attendee, so review the zero-attendee meetings before you trust the exclusion.

Check your setup read-only

Take the account with the most linked meetings in the last 90 days. List those meetings. For each meeting, count attendees whose email domain belongs to that account.

Passes ifEvery meeting with zero attendees from the account is excluded from engagement counts and from recurring-meeting flags.

Access needed:call-datacontext-readlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Pick one account with a high meeting count.
  2. 02List its linked meetings for the last 90 days.
  3. 03Count attendees from the account's email domains for each meeting.
  4. 04Mark each meeting with zero such attendees as internal-only.
  5. 05Compare the account's meeting count with and without those meetings.
Applies ifYour engagement or relationship score counts meetings linked to an account by id.
FailurecurrentGTM data

A prior-contact check on your CRM misses mail your sequencer sent

A check for earlier outreach can come back clean for people already mailed, because the sequencer keeps its own log and never writes to the CRM.

SymptomA prior-contact check on the CRM and the mailbox graph reports no earlier outreach for a person your team already mailed.

Before a campaign I check whether anyone on the list was contacted before, and a first design that reads the CRM activity history and the mailbox graph, the standard places to look, can come back clean for people a sequencer already mailed. A sequencer with its own send log never touches the connected mailboxes or creates a CRM activity. The CRM only holds mail that a sync or a person logged there, and a sequencer is a third writer with its own record.

The failure is quiet since the check does not error. It returns an empty result that reads as never contacted, so the people the check was built to protect can get a second cold message.

Mail from a sequencer often does not pass through the rep's mailbox. Because many setups log to the CRM only for connected mailboxes, the send exists in exactly one place, the sequencer's own log.

The remedy is to treat every tool that mails people as a source for the prior-contact check. Read the CRM, the mailbox graph and each sequencer's send log together, and match on the person instead of the mailbox. A check that skips one source answers a smaller question than the one you asked.

A send log shows what the tool attempted, not replies handled elsewhere, so read both before you call a person fresh.

Check your setup read-only

List the people your sequencer mailed in the last 30 days. Take the 10 most recently mailed. Look up each person in the CRM activity history and count the matches.

Passes ifEach of the 10 people has a CRM activity for the message, or the check also reads the sequencer log.

Access needed:crm-readlocal-config

If it fails: changes to make later (not part of the check)
  1. 01List every tool and mailbox that mails people for your team.
  2. 02For each one, find where it records a sent message.
  3. 03Pick 10 people the tool mailed in the last 30 days.
  4. 04Look up each person in the CRM activity history.
  5. 05Count the people with no matching CRM activity.
  6. 06Compare that count with the tool's own send log.
Applies ifYou use a sequencer or a separate sending domain and a prior-contact check reads only the CRM or the mailbox graph.
FailurecurrentRunning agents

A usage limit reaches a headless agent as plain text instead of an error

When a scheduled claude -p run hits the plan's usage limit, the message arrives as ordinary output, and a job can still end with exit code 0.

SymptomA scheduled agent job shows success, but its output is one line about a usage limit and none of its real work.

I expected a usage limit to fail a headless run loudly, yet the CLI printed one line, 'You've hit your … limit', as normal output. Several jobs wrote that line into their own dated logs and finished with exit code 0, so a status check saw success even though the work had not happened.

My first detector read exit codes, so it saw nothing. The second scanned the output for the limit line, but loose matching caught ticket titles and a search vendor's own 'usage limit reached' text. The line needs an anchor on its exact shape, and the plan limit and the spend cap need separate checks, because both lines can name a time the limit lifts.

One digest job echoed the message cut at 100 characters. The time the limit lifts was in the cut part, so the retry used a default wait and ran too early. Jobs that keep CLI output in a per-run folder were invisible to a scan of the main log. Those jobs have to print the limit line themselves and record a stop reason.

The fix is the same for every job. Read the output as well as the exit code, anchor on the message shape, and record a stop reason when the limit text appears. Then a limit is a known stop with a retry time rather than a silent success.

Check your setup read-only

Search each scheduled job's log for the text 'hit your' followed by 'limit'. Compare each match with the recorded status of the same run.

Passes ifEvery run whose log holds that text also shows a failure status or a recorded stop reason.

Access needed:scheduleragent-transcripts

If it fails: changes to make later (not part of the check)
  1. 01Search every scheduled job's log for the text 'hit your' followed by 'limit'.
  2. 02Match each hit with the run's exit code.
  3. 03List the jobs that keep CLI output outside the main log.
  4. 04Make each job print the limit line and record a stop reason.
  5. 05Keep the full line so the time the limit lifts survives.
Applies ifYou schedule headless claude -p jobs and judge a run by its exit code or by the last line of its log.
FindingcurrentRunning agents

Most stops in an agent queue never needed the human

I classified why agent tickets stopped and found that almost none stopped on output quality.

SymptomAgent tickets sit in Review or Waiting for days, and your next planned fix is another reviewer.

Agents on my queue finish work and stop for me. When the pile grew, the intuitive fix was more and better review.

On the day I counted, most of my open tickets sat waiting in Inbox or Review. I audited 19 recorded stoppage analyses and found that almost none stopped on output quality. Evals passed, and reviews caught and fixed defects in the same run. The stops fell into three classes.

  • Reach: an input the agent couldn't get to, like a vendor UI or an unreadable config.
  • Land: a finished deliverable with no apply path for its kind, like a commit outside a repo.
  • Judgment: a call that really was mine.

Each agent had already named its own fix.

Every finish carried a comment with the grant that would have unblocked it. Most were never acted on, because a grant judged against one ticket looks not worth it, even when it is obvious across its class.

The mechanical stops now get a deterministic pass. It releases gates whose dependencies are done, closes advisory-only reviews, and asks a read-only model referee whether a stuck ticket holds a defect, an improvement or a real floor.

Check your setup read-only

Read your last 20 agent handbacks or blocked-ticket notes in the work queue. Sort each one into couldn't reach an input, couldn't land the result, or needed a real decision. If reach and land together outnumber real decisions, more review targets the wrong problem.

Passes ifReal decisions make up at least half of the 20 sampled stoppages.

Access needed:agent-transcriptslocal-config

If it fails: changes to make later (not part of the check)
  1. 01Have each agent log its blocker in 3 lines to a ledger, not a comment. The 3 lines are blocker, minimal grant and class.
  2. 02Cluster blockers seen on 2 or more tickets into at most 3 proposed grants each week.
  3. 03Decide grants per class, ranked by class frequency times cheapness, never per ticket.
  4. 04Expire every 'this capability doesn't exist' note. Re-probe the capability before a run relies on the note.
  5. 05Let a deterministic pass release met gates and close advisory-only reviews. The pass comments first with an undo line.
Applies ifYour work queue holds agent handbacks to a person, and its waiting count grew week over week.
TechniquecurrentGTM data

An invented "because" passes a claim-by-claim grounding check

Two true facts joined by a made-up cause pass a claim-by-claim grounding judge.

SymptomAn agent's answer links two cited facts with "because" or "so", each fact checks out, and a sentence-level grounding check passes the answer.

Grounding judges check an answer's claims against its sources. An answer can join two claims that both check out with a cause the sources never state, and still pass.

"The deal slipped because the champion left" makes three claims, because the link is a claim too, alongside the slip and the departure. A judge that grades the sentence against its sources finds the first two and passes it.

A judge that lists claims before it decides will catch it. Before the verdict, it writes out each claim and the type of link between claims, so a cause with no source behind it becomes its own failing claim.

Dates don't need a model. Compute date relations in code before the judge runs, and "past due" on a date after the organization's as-of date fails on arithmetic, with no model call.

Check your setup read-only

Take the 10 most recent answers your grounding judge passed that contain "because", "so" or "due to". Look in the cited sources for a source that states the causal link itself, not just the 2 facts. More than 1 of 10 with a link no source states means the judge misses invented causes.

Passes if9 or more of 10 sampled passed answers with a causal word cite a source that states the link itself.

Access needed:agent-transcriptscontext-read

If it fails: changes to make later (not part of the check)
  1. 01Have the judge list every claim and the type of link between claims before it gives a verdict.
  2. 02Grade each causal link as its own claim. Pass a causal link only if a source states the link.
  3. 03Compute date relations in code, such as before, after and past due. Hand the results to the judge.
  4. 04Fail any "past due" or "overdue" claim whose date is after the organization's as-of date, without a model call.
Applies ifYour job config runs a grounding check on summaries or alerts that explain why something happened.
FindingcurrentGTM data

Re-logged call summaries crowd the calls out of an agent's evidence

When a call is re-logged as CRM tasks, those tasks can outweigh the call in the evidence.

SymptomMost facts behind an account answer cite CRM tasks that summarize a call, while the call's own transcript barely appears.

Revenue teams re-log the same content across systems. When a call summary lands in a CRM task, the agent sees the call once as itself and again as the task.

Re-logged summaries can easily outnumber the calls they restate, so copies win on volume.

An evidence limit is fixed, so copies push sources out. When re-logged tasks fill it, the transcripts they summarize, with the detail the summary dropped, miss the cut.

Having more facts does not mean having more evidence.

In a synthetic test set of calls re-logged as CRM tasks, filling a 40-fact limit by score kept 15 transcript facts from 14 calls; putting each call ahead of the tasks that restate it kept 40 transcript facts from 26 calls. The set shows the mechanism, not how common it is.

When you link tasks to calls, check that a re-logged summary and a rep's own notes on the same call are not both treated as copies.

Check your setup read-only

Take the 10 most recent agent answers about an account in your transcripts. Count the cited facts that come from logged CRM tasks. Count the cited facts that come from the calls those tasks summarize. If the tasks outnumber the calls they restate, copies are crowding out the primary source.

Passes ifIn all 10 sampled account answers, citations from logged tasks don't outnumber citations from the calls those tasks summarize.

Access needed:agent-transcriptscrm-readcall-data

If it fails: changes to make later (not part of the check)
  1. 01Find logged tasks whose text restates a call summary. Link each task to the call it came from.
  2. 02Put the call in the evidence first when a task and its call are both candidates.
  3. 03Count a task and the call it restates as one source when filling the evidence limit.
Applies ifYour jobs back-fill email or call activity into the CRM as tasks, and your agent's store also holds the call transcripts those tasks summarize.
TechniquecurrentRunning agents

More agents grow the backlog while a closing job and one capped channel shrink it

Nothing closed work until one job took over closing and one channel carried every ask.

SymptomYour work queue's Inbox and Review counts climb week over week while no automation closes anything.

Every job, agent and session I run files follow-ups, scan findings and handbacks, and nothing closed that work. Most of the queue sat in Inbox, and a steady tail waited on review or on me.

When agent capacity is idle and I am the constraint, more producers only add stock.

The parts that pay off cut decisions. One capped voice wakes me through a nightly brief with one card per item, while specialist jobs stay silent on empty runs. One reply such as 'yes 2 except one' clears a whole set.

The closer works in four steps.

  • A deterministic pre-pass finds duplicates, work done elsewhere, quiet decisions and stale tickets.
  • One read-only model session proposes verdicts.
  • The runner re-checks the evidence itself and applies at most 25 moves.
  • If I reopen 2 moves inside 7 days, it drops to proposals only.

The closer's first runs merged only about one candidate in fifteen, because what remained was my own decisions.

Quiet by default needs proof of life. Two of my jobs failed by building a digest, having the post blocked, and exiting cleanly. Now each job declares whether its post is its health signal. About one in ten do.

Check your setup read-only

Count the items waiting on you today by state, from your work queue's state counts. Count the items any automation closed last week, from the queue's close history. If the waiting count grew and the automated close count is zero, that's a gap.

Passes ifAutomation closed items last week, or the count waiting on you held flat or fell.

Access needed:local-config

If it fails: changes to make later (not part of the check)
  1. 01Route every report through one capped digest. Keep specialist jobs silent on empty runs.
  2. 02Let the closer act alone only on evidence the runner can verify. Verifiable evidence is a related ticket done, or a path or commit that exists.
  3. 03Keep absence-based moves as questions in the digest, never closes. Absence-based moves cover items stale 30+ days and decisions quiet 14+ days.
  4. 04Log every move with its prior state. Cap moves at 25 a run. Halt on 2 human reopens within 7 days.
  5. 05Alarm when a job whose post is its health signal passes without its post.
Applies ifYour work queue is the board, ticket list or file where agents file items for a person to act on. It shows one approver for items that several jobs and agents file.
FindingcurrentRunning agents

Agents assume before acting and claim after, both without checking

Unchecked assumptions before acting and unchecked claims after made up 46% of my agents' errors.

SymptomYour agent replies done, live or verified in a turn where its transcript shows no tool call after your request.

When I classified four months of my agents' errors, the two biggest causes looked separate. One was wrong assumptions about state (a file, a field, a job, a flag). The other was claims of done or live made without checking.

They turn out to be one failure in two tenses, since the assumption comes before acting and the claim comes after. Together they accounted for 46% of 106 errors, and the classifiers judged that verifying before claiming would have prevented 43%.

That points at one mechanism instead of ten rules. A hook at the end of each turn flags any done, live, published or verified claim made with no tool call since the prompt that read the system it describes.

The Claude Code hooks reference lists Stop as an event whose exit code 2 prevents Claude from stopping and continues the conversation, so an end-of-turn check can send the agent back to work.

A second hook answers "didn't we already decide" from my decision log instead of from anyone's memory.

The measurement mattered as much as the gate. A zero-token regex miner flags candidate turns across every transcript in seconds, then blind classifiers label them. 61% of flagged episodes were noise.

Not every signal is equally trustworthy. How often each flag was a real error:

  • The agent's own admission of an error: 69%.
  • Challenges like "are you sure": 29%.
  • My correction-shaped turns: 12%.
  • My interrupts: 3%, because they are redirects rather than error reports.
Check your setup read-only

Read your agent's last 20 replies in its transcripts that say done, live or verified. Count the replies with no tool call, between the request and the claim, that read the system the claim describes. More than 2 of 20 means claims are going out unchecked.

Passes if18 or more of 20 sampled done, live or verified claims follow a tool call that read the system described.

Access needed:agent-transcripts

If it fails: changes to make later (not part of the check)
  1. 01Flag any turn that claims done, live, published or verified with no qualifying tool call since the request. A qualifying tool call reads the system that the claim describes.
  2. 02Mine transcripts with a regex pass first. Send only flagged turns to a classifier.
  3. 03Weight the agent's own error admissions highest when counting errors.
  4. 04Do not count interrupts as errors.
Applies ifYour agent reports status such as done, live or verified to people in chat, tickets or digests.
FindingcurrentGTM data

A record's age is not the age of your sync

Report the CRM's last-edited date and the sync time as two separate facts.

SymptomAn agent tells a user their data is stale when one record simply hasn't been edited in months.

A CRM's last-modified date says when someone last edited a record, and says nothing about when your copy was last refreshed. When an agent sees an old date and calls the data stale, it merges the two.

Two clocks are at work here, and they track different things.

  • Last modified: when a person or process last edited the record in the CRM.
  • Sync time: when your system last read it.
  • A record can be old in the CRM and current in your copy.

Mixing the two sends users after the wrong problem. Told their data is stale, they doubt the sync and every answer built on it, even though all that happened is that one record hasn't been touched.

Saying both dates avoids that confusion, since last edited in the CRM is a fact about the account and last synced is a fact about the pipe.

Salesforce keeps two last-edited dates, so say which one you report. LastModifiedDate moves when a user or an integration edits the record, while SystemModstamp also moves for system changes.

Check your setup read-only

Read the 10 most recent answers where your agent comments on freshness. Compare each answer with the record's CRM last-modified date and the last run time in your sync job's log. Any answer that blames the sync for an old last-modified date conflates the two.

Passes ifAll 10 sampled freshness answers report the record's last-modified date and the last sync time as separate facts.

Access needed:agent-transcriptscrm-readscheduler

If it fails: changes to make later (not part of the check)
  1. 01Give the agent the CRM's last-modified date and your last sync time as 2 separately named fields. Add both fields to every record the agent reads.
  2. 02Have the agent describe freshness with both dates: the last edit in the CRM and the last sync.
  3. 03Call the sync stale only when the sync time is old. Report an old last-edited date as its own fact about the record, not as a sync problem.
  4. 04Say that a record hasn't been edited when the record is old but freshly synced. Name the date.
Applies ifYour agent or digest output tells sellers how current a CRM record is, such as a contact's title or an account's last activity.
TechniquecurrentGTM data

Agents need the business clock in the answer instead of an optional tool

Fiscal years and as-of dates belong in every response the agent reads.

SymptomAnswers about "this quarter" use calendar quarters for a company whose fiscal year starts in another month, and date windows drift from the data.

Many companies run a fiscal year that doesn't start in January, and some datasets are pinned to an as-of date rather than today. An agent doing date math from the wall clock and calendar quarters gets both wrong.

A fiscal calendar kept in free-text instructions reaches only the interface that reads them.

Agents don't reliably call an optional tool, and a separate tool helps only when the agent thinks to ask. Putting the values in tool responses, or on the records themselves, works better.

The wall clock is also the wrong anchor for an organization whose data is frozen at a past date, because windows measured from today slide past the data and recent history drops out of answers.

In a synthetic test set of 1,000 activities pinned to a past as-of date, windows anchored on today's date returned no rows for "last 90 days" or "this quarter"; windows anchored on the as-of date and the fiscal calendar returned 118 and 11. The set shows the mechanism, not how common it is.

Check your setup read-only

Find the last 5 agent answers in your transcripts that name a quarter, a week or "today". For each answer, compare the dates it used with the CRM's fiscal calendar. Read the transcript before the answer for a read of the fiscal calendar and of the data's as-of date. Any date mismatch is a gap. An answer given without reading both dates is also a gap.

Passes ifIn all 5 sampled answers the dates match the fiscal calendar, and each transcript shows both reads before the answer.

Access needed:agent-transcriptscrm-read

If it fails: changes to make later (not part of the check)
  1. 01Return timezone, as-of date and fiscal-year bounds in the tool responses the agent already reads.
  2. 02Tell agents to read those values from the tool responses before any date math.
  3. 03Anchor every relative window on the organization's as-of date, not the server clock. Relative windows include "last 30 days" and "this quarter".
  4. 04Store the fiscal calendar as structured fields, never only in free-text instructions.
Applies ifYour agents or digests answer this-quarter or last-week questions, and your CRM's fiscal year starts outside January or data is pinned to a past date.
FindingcurrentRunning agents

Most of my agents' questions shouldn't have been questions

Seven in ten held items asked me whether they should run.

SymptomItems waiting on a human pile up in your agent queue while the dispatcher uses a fraction of its capacity.

My agents file follow-up work to a ticket board that other agents pick up. The default for anything uncertain was "decide whether to run", which turned every cheap, reversible follow-up into a go/no-go question for me.

It looked like a throughput problem, though the limit was my attention.

  • Held items asking only whether to run: about 70%.
  • The same share in August: 90%.
  • Dispatcher use: under a third of its daily capacity.

So I flipped the default to run, with a veto. Reversible local work runs on the next pass and I drag back what I don't want. Sends, CRM writes, spend and live config stay behind structural gates however a ticket is filed.

Inside a session the same logic is a redo test. A question qualifies only if a wrong guess means redoing work, or if it is an approval gate. Everything else gets a stated default.

Check your setup read-only

Read the items in your agent work queue that are waiting on a person. Count the items that only ask whether to run reversible work. More than a third means your filing default is the bottleneck.

Passes ifA third or fewer of the queue items waiting on a person ask only whether to run reversible work.

Access needed:local-config

If it fails: changes to make later (not part of the check)
  1. 01File reversible local work such as code, docs, analysis and proposals as ready to run. Let the human veto.
  2. 02Gate sends, CRM writes, spend and live config by class, not by how the item is filed.
  3. 03Make any item marked as a decision name the call: which option, which scope, or whether it should exist.
  4. 04Ask only when a wrong guess means redoing work. Batch questions at the end, with at most 2 rounds per thread.
  5. 05Revisit if more than about a quarter of auto-run follow-ups are rejected over 2 weeks.
Applies ifYour work queue is the board, ticket list or file where agents file items for a person to act on. It holds agent-filed items waiting on your go-ahead, and the dispatcher's run log shows idle slots.
TechniquecurrentRunning agents

Have the agent judge overbuild instead of the human

Every proposed new job, hook or script must say what breaks without it.

SymptomYour list of scheduled jobs, hooks and scripts only grows, and several have no run or read in the last month.

Unneeded moving parts barely show in error data because an approver tends to accept them, leaving over-building at about 3% of classified errors. I can't reliably judge overkill mid-flow, and a written "default to lean" rule sat in memory for months without changing a recommendation.

So the check sits where approval happens.

A hook on the agent's question tool refuses any option that adds a moving part until it carries two lines, "Without it:" (what breaks, from evidence) and "Smallest:" (the lightest alternative, including doing nothing yet).

I picked that trigger by backtest. Scanning the agent's free text fired on 5.8% of replies, mostly checklists. The approval-call trigger hit about one question in ten.

It changes recommendations. In the latest weekly run it again fired on about one logged question in ten, and more than a third of those re-asks came back with a different recommendation.

Increments add up unnoticed, as in one afternoon when a calendar grew into a board, templates, an audit and a scoreboard.

Check your setup read-only

List the jobs, hooks and scripts added in the last 90 days, from the job registry and hook config. Leave out jobs that run less often than monthly. Leave out alarms that only fire on failure. Look in run logs and session transcripts for a run or read of each in the last 30 days. Any item with neither is a retirement candidate.

Passes ifEvery job, hook or script added in the last 90 days ran or was read in the last 30 days. The exclusions are jobs that run less often than monthly and alarms that only fire on failure.

Access needed:schedulerlocal-configagent-transcripts

If it fails: changes to make later (not part of the check)
  1. 01Refuse a proposal for a new job, hook, script, ticket, review pass or store until it states 2 things. The 2 things are what breaks without the addition and the smallest alternative.
  2. 02Trigger the check on the approval call, not by scanning free text.
  3. 03Defer each component to a named trigger, never a bare later.
  4. 04Flag the growth after 3 increments to one system in a session, before a fourth increment.
  5. 05Propose each month the removal of anything built 30 or more days ago that nothing uses. Exclude jobs that run less often than monthly and alarms that only fire on failure.
Applies ifYour work queue is the board, ticket list or file where agents file items for a person to act on. It, or your transcripts, show agents proposing new jobs, hooks or scripts that a person approves.
FindingcurrentGTM data

Being invited or mentioned does not mean someone attended a meeting

Calendar, RSVP and recording data each answer "who was there" differently.

SymptomAn AI-written profile says a person attended a meeting and holds the decision. The only evidence behind the claim is an invite or a mention in an email.

A meeting record looks like it answers who was there. The calendar, the RSVP and the recording each tell a different story, and the obvious join treats every listed name as an attendee.

The sources disagree in predictable ways:

  • A recorded call never marked as held.
  • One meeting split across several records with conflicting states.
  • A "declined" RSVP from someone the recording shows speaking.
  • Transcript participant lists that copy the invite list.

The invite list is the trap. On many calls, some listed people never joined. Gong's API reference for extensive call data marks each participant's methods as Invitee or Attendee, so being invited and having attended are separate values. Mention-only links are common too, such as an email that names someone who never joined the meeting.

Agents read tool wording literally. One loose sentence can make an agent count invitees as attendees. A single sentence saying everyone listed still counts can flip an agent's answers from right to wrong.

Check your setup read-only

Take the 20 most recent attendee claims in your agent's transcripts. Look for each person in the recording's speaker list or the CRM's held-meeting record. More than 3 of 20 found only on the calendar invite means the agent reads attendance from calendar invites.

Passes if17 or more of 20 sampled attendees appear in a recording's speaker list or a held-meeting record. A calendar invite alone does not count.

Access needed:agent-transcriptscall-datacrm-read

If it fails: changes to make later (not part of the check)
  1. 01Give every meeting one state: held, proposed, scheduled or canceled.
  2. 02Carry each person's strongest link onto the meeting: spoke on the recording, accepted, invited, or only mentioned.
  3. 03Let a transcript outrank weaker flags such as an RSVP or a missing held mark.
  4. 04Name invited-only people separately in tool output. Say plainly that invited-only people are not counted as attendees.
Applies ifYour jobs read calendar invites and call recordings for the same meetings, to back-fill the CRM or tell sellers who met whom.
FindingcurrentRunning agents

Most B2B teams lack the deal volume a self-learning signal model needs

Below a vendor's outcome floor, learn per detector and call it human-tuned.

SymptomA signal or scoring tool promises a model that learns from your outcomes, and you close far fewer deals a year than its model needs.

Signal vendors describe self-learning models, and their own documentation states the outcome volume those models need. Salesforce's Einstein Opportunity Scoring asks for 200 won and 200 lost in two years, and vendors such as MadKudu also set minimum training volumes. The clinical rule of thumb is ten outcomes of the rarer class per model parameter.

Most teams selling large B2B deals close well under that floor, which buys one or two parameters. A per-account propensity model is out, and it answers the wrong question because it ranks accounts by the chance of an opportunity when the question is when and through whom.

Per-detector precision starts wide and stays wide. A detector that fires 20 times and precedes 2 meetings has precision 0.10, with a 95% interval (Wilson) of roughly 3% to 30%. Zero of 20 still allows up to 16%.

If your team is below that floor, priors do the first year's work and a person does the learning, so human-tuned is the honest label.

Targeting confounds the rest because reps work the accounts you scored highest, making every fit signal look predictive. A top fit tier can end up holding a large share of new opportunities simply because that is where the effort went.

Below that floor, a single detector's precision takes a long time to become measurable. Counting replies as a secondary outcome adds labels, at the cost of a proxy that can lie.

Check your setup read-only

Count your closed-won and closed-lost opportunities over the last 24 months. Compare the counts with the vendor's published training floor, such as 200 won and 200 lost. Below the floor, the model isn't learning from your data.

Passes ifYour closed-won and closed-lost counts both meet the vendor's published training floor.

Access needed:crm-read

If it fails: changes to make later (not part of the check)
  1. 01Learn precision per detector, not per account. Report precision with a 95% interval, never a point estimate.
  2. 02Write each detector's prior as pseudo-counts with its source. Let data outweigh the prior only once fires exceed the pseudo-count.
  3. 03Pool detectors into families so a family can learn where a single rare detector can't.
  4. 04Measure conversion only among worked accounts, never with raw opportunity counts. Use meetings per routed card and replies per touch as the measures.
  5. 05Route 2 below-threshold cards a week as a work-anyway slice, marked as exploration.
Applies ifYour CRM or a connected vendor tool scores accounts or signals with a model that learns from your outcomes.
TechniquecurrentRunning agents

A recommendation has to show what would change it

If you take most picks, each pick needs its own counterweight.

SymptomYour approval log shows you took the recommended option on most questions, and the cards give no reason the others lost.

When one person approves many agent questions a day and takes most picks as offered, an unchecked recommendation is a ruling made by whoever wrote the card.

So every recommended option carries two lines. "Why" gives the reason. "Would change if" names the fact that would flip it, which hands me something specific to check instead of a reason to nod.

Config and destructive questions, about 13% of the total, also get a blind second opinion. A read-only agent sees the options shuffled, never the pick.

An option is only as good as its mechanism. One card offered loading records through a vendor table that the vendor's command-line tool couldn't write to. I picked it, the agent dead-ended, and I did the import by hand.

I also link later corrections back to the followed pick.

Check your setup read-only

Read the 20 most recent approval questions in your agent's transcripts or decision log. Count the recommended options that state the condition under which another option would win. Fewer than 15 of 20 means picks arrive without a stated condition for another option.

Passes if15 or more of 20 sampled recommendations state the condition under which another option would win.

Access needed:agent-transcripts

If it fails: changes to make later (not part of the check)
  1. 01Require a Why line and a Would change if line on every recommended option.
  2. 02Add a second opinion to config and destructive questions. Get the opinion from a read-only agent shown the options shuffled and not the pick.
  3. 03Probe each option's mechanism once with a help page, a dry run or 1 test call before offering it.
  4. 04Link corrections made within 6 hours in the same folder back to the pick they followed.
Applies ifYour decision log or transcripts show agent approval questions on most days, and the recommended option wins most of them.
FindingcurrentRunning agents

A lessons log agents 'read at start' becomes write-only

Once the file outgrows one read, agents stop following the instruction to read it.

SymptomYour agents are told to read a lessons file first, and transcripts show them repeating mistakes it already records.

Every workspace I run keeps a lessons log, and my agents were told to read it at session start. Writers append forever, because saving a lesson is cheap and encouraged.

Over two weeks across dozens of files, almost nothing read them. Under 2% of sessions opened a log at all, and the largest file, close to a tenth of the total, was opened zero times.

The second fault was location, because sessions open in whatever folder is selected and then work across many. Loading and filing by the session's folder was wrong. An audit of every entry found two results.

  • The root log was 82% other workspaces' lessons.
  • About one entry in fifty had been written into temp folders and deleted with them.

The cleanup had its own trap when classifiers read the heads' summary bullets as entries and archived 49 full entries as duplicates of their own summaries.

Deciding which lessons earn head space is a judgment call, so to measure misses, check whether a correction that repeats a covered mistake had its lesson in the head or only in the archive.

Check your setup read-only

Count the sessions that opened the lessons file at all in your last 20 agent session transcripts. Compare the file's size with what one read returns. If most sessions never open the file, that's a gap.

Passes ifAt least 11 of 20 sampled sessions open the lessons file, and its read-first part fits in one read.

Access needed:agent-transcriptslocal-config

If it fails: changes to make later (not part of the check)
  1. 01Open each log with a curated head of 6 KB or less. Put one lesson that still applies per line in the head, each with a grep handle.
  2. 02Keep everything else verbatim below as an archive to grep, never to read whole.
  3. 03Run a weekly script with no model. The script flags a large file with no head, a head over budget, or 20% growth.
  4. 04Inject a folder's head the first time a session touches that folder. File each lesson by subject. Deny temp-folder writes.
  5. 05Exclude digest sections from any bulk classification of entries.
Applies ifYour agent instruction files tell agents to read a notes or lessons file before they work.
TechniquecurrentRunning agents

A rule that keeps getting broken needs a gate instead of a sharper rule

With about 350 written rules in place, my agents' top two errors weren't falling.

SymptomYour agent instruction file gains a rule after each mistake, and the same error class shows up again within weeks.

My coding and GTM agents share one memory of behavioral rules, and each mistake used to earn a new one. By October that memory held about 350 rules.

When I classified four months of caught errors, those rules weren't working.

  • Three blind classifiers labelled four months of prompts from June to October.
  • 106 errors were on the agent's side.
  • 25% were claims made without checking.
  • 22% were wrong assumptions about state.

Rules for both top causes already existed. The verification section alone held 28, and neither cause declined in October while design-iteration errors did.

The rules were also crowding each other out. The index that loads them at session start was over its size budget and being cut off at load, so each new rule made older cues less likely to fire.

So I stopped writing prose rules for covered causes. A weekly job mines new error episodes and matches each cluster against the rule inventory. For any cause a rule already covers, that job may only propose a gate or a cue rewrite.

The Claude Code memory documentation says memory files are treated as context rather than enforced configuration, and points to PreToolUse hooks for blocking an action regardless of what Claude decides.

Check your setup read-only

Pick the error class your agents hit most this month from your correction or error log. Find the rule in your instruction files that covers that class. Count recurrences in transcripts since that rule existed. 2 or more recurrences under an existing rule means the rule isn't holding.

Passes ifThe most frequent error class recurred at most once since its rule existed, or a code check now blocks it.

Access needed:local-configagent-transcripts

If it fails: changes to make later (not part of the check)
  1. 01Classify the last month of agent errors by cause before adding any rule.
  2. 02Find the rule that should have caught each cause that recurs 2 or more times.
  3. 03Replace that rule, if it exists, with a running check such as a hook, lint or test.
  4. 04Rewrite the rule's one-line trigger, not its body, if no check is buildable yet.
  5. 05Add a new prose rule only for a cause no existing rule covers.
Applies ifYour agent instruction files loaded at session start hold more than about 50 behavioral rules.
FindingcurrentGTM data

CRM permissions make an invisible field look empty

When a sync loses read access to a field, that field reads as null.

SymptomA CRM field goes blank on every new record after one date, older values stop moving, and the sync logs no error.

A connector reads a CRM through one integration user and sees only the fields that user can see, so a single permission-set change can hide dozens of fields at once.

To the sync, a field it can no longer see looks exactly like a field that is empty. A connector that builds its query from the schema simply stops asking for the field, so no error is logged and the values stop arriving.

Incremental sync makes it worse. It re-reads only rows edited since the last run, so values captured before the change freeze in place and never refresh. Fivetran's Salesforce connector FAQ says that after a column's permission is removed and then granted again, only new records sync and older values need a table re-sync.

A history of each object's schema, snapshotted on every sync, tells the two apart. In such a history, a permission change shows as a single transition where many fields vanish at once, while the record values show nothing.

Check your setup read-only

Read the CRM's field permission metadata today. List the fields your integration user can read on each synced object. Compare that list with the field list your first full sync captured. Any field in the old list that is missing now is a gap.

Passes ifEvery field your first full sync captured is still readable by the integration user today, on every synced object.

Access needed:crm-readlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Snapshot each synced object's field list on every sync run and keep the history.
  2. 02Treat a previously synced field that disappears from an object's schema as an incident, never as a column of nulls.
  3. 03Alert the CRM admin and the data owner within the hour a synced field vanishes.
  4. 04Run a full re-sync of the object after access is restored. Incremental sync never revisits records edited before the gap.
  5. 05Check that the field is still in the integration user's schema before reading a null as empty.
Applies ifA job reads or fills CRM contact fields through an integration user whose permissions an admin outside your team controls.
FindingcurrentGTM data

A CRM amount is a number whose currency sits in a separate field

Summing amounts across record currencies produces a meaningless total with no error.

SymptomA pipeline total mixes dollar and euro deals with no warning. A "largest open deal" answer returns a yen deal whose raw amount is far above the real largest.

In a multi-currency CRM, each opportunity's amount is stored in the record's own currency. The currency sits in a separate field, and its name differs from one CRM to another.

An amount without its currency still adds up cleanly. In a warehouse copy, or when summing raw records you pulled, a query that sums or ranks the amount field returns a confident number, and nothing flags it. In Salesforce, a grouped total comes back in the org's default currency. A plain query returns each amount in its own record's currency.

Ranking is worse than summing. A yen deal can top "largest open deal" with a raw amount many times that of the real largest.

Agents request only fields they know exist. If nothing names the currency field next to the amount, they never ask for it.

An agent given a clear error corrects itself. Refuse a mixed-currency total with a message saying to filter or group by currency, and the next question can come back split by currency.

In a synthetic test set of 90 opportunities in three currencies, ranking on the raw amount put a yen deal first that is worth less than the largest dollar deal, and the raw total came to 42 times the converted total. The set shows the mechanism, not how common it is.

Check your setup read-only

Count the distinct currency codes on open opportunities. Find the field that holds the record currency in each CRM you read. More than 1 code is a gap if any report or agent-tool aggregate doesn't group by that field.

Passes ifOpen opportunities carry one currency code, or every aggregate you read groups or converts by the record-currency field.

Access needed:crm-readlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Find the record-currency field in each CRM you read. Name that field next to the amount wherever an agent reads the amount.
  2. 02Sum, average or rank amounts only within one currency, or use the CRM's own converted amount in the corporate currency.
  3. 03Split grouped totals into one line per currency.
  4. 04Label a top-N list when its cutoff splits a tie or the list spans currencies.
Applies ifYour reports, digests or agents total CRM opportunity amounts, and multi-currency is turned on or you read more than one CRM.
TechniquecurrentRunning agents

Keep an agent queue's speed caps separate from what a run may touch

My agent queue's throughput caps govern speed, never what a run may touch.

SymptomRaising a daily cap or a parallel-slot count on your agent queue also widens which tools or systems a run can reach.

I build GTM systems with agents. They work from a board with many dials, such as how much work starts each day, how many runs go in parallel and how crashed runs restart. Each time I loosened one, the worry was that I had loosened safety with it.

I answer it by construction. Every dial is a rate limit, and none can widen what a dispatch may do. Reach lives in floors that no throughput setting touches.

  • Nothing sends outward, under any label.
  • A deny list covers paths no agent may edit.
  • Anything that writes to a live system goes through a separate approval lane.

That split let me move fast on throughput. Because reach is fixed by separate floors, throughput changes don't need a safety review.

Parallel slots have moved up and down. When a higher setting ran through the token budget, I turned it back down as a cost limit rather than a safety one.

Ordering follows the same rule. A blocked ticket inherits its blocker's place in line and capability labels, never the most powerful one. A comment from me on a parked ticket resumes it from its existing files, ahead of the queue.

Check your setup read-only

Find the agent runner: the script or service that starts agent runs from a queue. Search your scheduler entries for the command that starts agent runs. Open the config file that command reads, with slot counts, concurrency or daily caps. List every cap in it. Compare each cap with the runner's capability grants. A cap is a gap if raising it would widen the tools, labels or systems a run can reach.

Passes ifEvery cap in the runner config limits throughput only. The tools, labels and systems a run can reach come from separate grants.

Access needed:local-config

If it fails: changes to make later (not part of the check)
  1. 01Record whether each cap limits speed or reach. Keep reach out of every environment variable and label.
  2. 02Enforce reach with floors. The floors are no outward sends, a deny list of protected paths, and a separate approval lane for live writes.
  3. 03Reserve some dispatch capacity for intake.
  4. 04Raise a cap to the size of the queue when the cap blocks approved work. Stay within what the shared token budget can carry. Do not raise the cap for one day only.
  5. 05Close extra parallel slots for 24 hours after any run that stops at the usage limit.
Applies ifA scheduler entry starts agent runs from a queue, and its config holds throughput caps for 2 or more agents.
TechniquecurrentRunning agents

Every agent result gets one fresh-eyes review

What the agent produced determines the lens, and the runner supplies the 'reviewed' line.

SymptomAgent results land marked done with no review file beside them, or with a 'reviewed' claim the agent wrote itself.

Only code had a reviewer on my agent queue. Everything else could close without one. An audit of two weeks of agent-closed tickets found about half had closed with no review at all.

Now no result reaches me, or closes itself, unless a fresh-context review ran on that dispatch, or it lands explicitly marked not reviewed. There is no skip label, so a trivial ticket still pays one cheap pass.

A classifier with no model reads the output folder and picks the lens from the deliverable's kind.

  • Code gets a code review.
  • A Salesforce write packet gets checked for scope, per-field values, blanks over live values, and a reversal snapshot.
  • A spec or plan gets an approach review.
  • Everything else gets a findings review so claims are traceable, the brief is covered, and untested parts are disclosed.

High-consequence work gets three loops with distinct lenses, each run even when the last came back clean.

The handback states what ran, built from the runner's own record, never from agent text. Agent text that imitates that line is removed, so an agent can't claim a review it didn't get.

Check your setup read-only

Look at your last 20 agent results marked done in the work queue. Count how many had a review by a separate session, from the review log or transcripts. Any done result without a review that isn't explicitly marked not reviewed is a gap.

Passes ifEvery one of 20 sampled done results shows a review by a session other than the working session. A sampled result explicitly marked not reviewed also passes.

Access needed:agent-transcriptslocal-config

If it fails: changes to make later (not part of the check)
  1. 01Require at least one fresh-context review session per dispatch before any result is marked done. Allow no skip label. Land the result explicitly marked not reviewed when no review can run.
  2. 02Choose the lens from the output's kind: code, write packet, spec or plan, or findings. Read the kind with a script, not from a label.
  3. 03Run 3 loops with distinct lenses for high-consequence work, even when earlier loops came back clean.
  4. 04Allow 3 fix cycles per ticket. Stop patching after the third cycle. Redraft from the brief instead of a fourth patch.
  5. 05Build the 'reviewed' line from the runner's record. Strip any agent text that imitates the line.
Applies ifYour work queue is the board, ticket list or file where agents file items for a person to act on. It lets agents mark their own results done.
TechniquecurrentRunning agents

Memory beats docs only when it's small and loaded by the work

Every session pays for an always-loaded index, and half of mine was boilerplate.

SymptomYour agent's always-loaded memory or rules file grows week over week, and pruning it never sticks.

My agents share one memory folder across every session and login. Its index loads into every session against a hard cutoff that the Claude Code memory documentation puts at 200 lines or 25 KB, whichever comes first, and lines past the cutoff silently stop loading.

Before the shared folder, memory split by where a session started, and about 40% of memories loaded in only about one session in fifty. One folder fixed recall and created a budget problem.

Pruning didn't help, because each fact was individually durable. Measuring showed that 7.5 KB of the 15.2 KB of rule lines was link boilerplate.

Grouping rules into themed hubs removed most of that. Then the per-rule cues on each hub's index line grew the index from 20.2 KB to 23.2 KB in a week.

Going pointer-only took the index from 22.4 KB to 7.8 KB. A hook loads a hub's cue list only when a tool call or prompt matches its triggers. A week's backtest put the median at one hub per session.

Rules with no tool or prompt signature never trigger the hook. For those, the pointer line's 'when to open' text carries the whole load.

Check your setup read-only

Measure the bytes and the line count of your always-loaded memory index file. Find its load limit in your agent tool's documentation. Claude Code loads the first 200 lines or 25 KB of MEMORY.md. If no documented limit exists, report the size with the limit as unknown. Count the bytes that are links, titles and prefixes, versus the words that trigger recall. Structure at 40% of the bytes or more is a gap. A file above 90% of its limit is a gap.

Passes ifLinks, titles and prefixes are under 40% of the index file's bytes. The file is at or below 90% of its documented load limit.

Access needed:local-config

If it fails: changes to make later (not part of the check)
  1. 01Keep the always-loaded index to 1 pointer line per file, 250 bytes or less, saying when to open it.
  2. 02Group rules into themed hubs. Put each rule's cue on the hub's own contents list, not in the index.
  3. 03Load a hub's contents list by hook, once per session, when a tool call or prompt matches its triggers.
  4. 04Gate memory writes. Refuse cue lists in the index and new standalone rule files. Refuse any memory with near-duplicate similarity to a live memory.
  5. 05Keep session state out of memory entirely.
Applies ifYour agents load a memory or rules file into every session and it is nearing its load limit.
FindingcurrentGTM data

Whether a meeting happened depends on which source saw it

"Took place" is an evidence rule over sources rather than a stored field.

SymptomMeeting counts include email threads that mention a date, past invites still marked scheduled, and transcript-born meetings with no state at all.

Most systems store a meeting state and trust it. Each source sets that state its own way, and none of them sees the whole meeting.

  • Email chatter about a call becomes a dated "meeting".
  • Calendar invites stay "scheduled" after the call happened.
  • Meetings created from a transcript carry no state at all.

So "took place" is a rule over evidence. A meeting happened if a recording shows an external participant speaking. One that started and was neither cancelled nor inferred counts as presumed held, labelled that way and ranked below a recording. Recording outranks calendar, and calendar outranks email.

A stored state field can miss a large share of the meetings that a recording or a started calendar entry shows were held.

In a synthetic test set where 136 meetings were held, the stored state field marked 52 of them held, plus 30 that were not; the evidence rule caught all 136 and also counted 5 presumed meetings that were not held. The set shows the mechanism, not how common it is.

Check your setup read-only

Take the rep with the most meetings last month, and that rep's last 20 past meetings. Count the meetings your stored "happened" field marks as held. Count the meetings with a recording of an external participant speaking, or a calendar entry that started and wasn't cancelled. A difference of more than 2 of 20 means the stored field is not the answer.

Passes ifThe evidence count covers meetings with a recording of an external participant speaking or an uncancelled calendar entry. For the sampled rep's last 20 past meetings, the stored held count is within 2 of the evidence count.

Access needed:crm-readcall-data

If it fails: changes to make later (not part of the check)
  1. 01Count a meeting as held when a recording shows an external participant speaking. Count a meeting as presumed held when it started and was neither cancelled nor inferred from email. Rank presumed held below a recording.
  2. 02Rank recording above calendar and calendar above email when sources disagree.
  3. 03Give transcript-born meetings a held state from the recording itself when it shows an external participant speaking.
  4. 04Compare your stored state against the evidence rule for one rep before trusting either.
Applies ifYou back-fill meetings as CRM activity, or report meeting counts per rep, from more than one source: calendar, recorder or email.
TechniquecurrentRunning agents

Flip an automation live in the session that proved the dry run

A proven dry run plus 'flip it on later' left my pipelines half-live.

SymptomYour job list or registry shows a job as live, but its recent runs logged dry-mode output.

Every new job I build that writes to an outside system (Salesforce, Slack, Notion, a published page) starts dry, behind one explicit live flag. That part worked, but the handoff after it didn't.

A dry run and a canary proved the path, and the flip became my terminal step for later.

Later turned into never often enough that proven pipelines sat half-live.

A job looked finished in its build notes and ran dry every night. Now the flip happens in the session that proved the path, with me running the gated command there. One dry run is enough for a deterministic job, and I hold only for a real prerequisite.

  • Code that hasn't landed yet.
  • A missing credential.
  • A send to people outside the team.

Two records keep it honest. Each job's actual mode sits in a registry that a daily check reads against its intent. And a dry run that mutates any state says so, because a dry run that advances a cursor is not dry.

Check your setup read-only

List your scheduled jobs that reach an outside system. Compare the live or dry flag in each loaded job's command line with the mode in your job registry. A flag can sit one hop away, in a wrapper script the command calls. Follow that hop before counting a mismatch. Any mismatch that remains is a gap.

Passes ifEvery job that reaches an outside system runs in the mode the registry records for it.

Access needed:schedulerlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Default every new external writer to dry, behind one explicit live flag.
  2. 02Flip the job live in the same session once 1 dry run and 1 canary pass. Do not wait for a multi-night soak or a clean week. Do 2 dry runs if a model runs inside the job. Compare token use and output counts before the flip.
  3. 03File a ticket if the flip can't happen in that session. Put the exact commands and the verification query in the ticket.
  4. 04Make a dry run state any write in its help text and its digest. The writes are a cursor, a registry row or a staging post.
Applies ifYour scheduler holds a job that writes to a CRM, a chat tool or a published page.
TechniquecurrentRunning agents

A hand-kept list of scheduled jobs drifts from what's actually running

Generate the job registry daily, and keep intent apart from wiring.

SymptomTwo docs disagree on whether a scheduled job is live, and its config passes no live or dry flag.

Dozens of recurring jobs run my GTM automation across five surfaces. They are the laptop scheduler, desktop tasks, cloud routines, managed agents and one interactive session. The registry was prose I had to remember to edit.

An audit found about one loaded job in five with no row, and nearly as many rows with the wrong schedule.

A script with no model now generates the registry every day from what is loaded, its schedule, its last fire and its result. A new job appears the day it is loaded.

A second audit showed a config can't say whether a job is live. Only about one in five job configs passed an explicit live flag. The rest passed nothing, and nothing meant live for some and dry for others.

So I record intent, what I want, apart from mode, what is wired today. A daily check reports the gap between them under its own "built, not live" verdict.

A scheduler read from a periodic cache rather than live lags by up to the cache's age, so the check also flags any cache older than its refresh interval.

Check your setup read-only

Compare your written job registry with the scheduler's loaded-job list and each job's config file. Match on the job's label. Read each schedule from the config file itself, not from a comment beside it. Look in the job's own code for a guard that skips the extra runs before you count a schedule difference. Any loaded job missing from the registry is a gap. Any schedule that differs between the registry and the config file is a gap. Any config that can't say live or dry is a gap.

Passes ifEvery loaded job appears in the registry with the same schedule, and every job config states live or dry.

Access needed:schedulerlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Generate the job registry daily from every scheduler's loaded state, with no model in the path.
  2. 02Hand-keep only fields no script can derive, such as which system a job belongs to and what it feeds.
  3. 03Record each job's intent apart from its wired mode. Intent is live, paused or retired. Mode is live, dry or partial. Record the date the mode began.
  4. 04Flag every job with intent live and mode dry or partial as "built, not live", with its age.
  5. 05Open a go-live ticket for any job that has sat in that state for 14 days without one. Put the exact commands in the ticket.
Applies ifYour setup has a written job registry and loads jobs in 2 or more schedulers.
FindingcurrentGTM data

A job change leaves two records for one person or keeps their old job

Any one-pick rule that ignores employment serves the employer a person left.

SymptomA person who changed jobs appears twice, or their profile shows the title and company they left.

Two standard rules meet at a job change. Same-name dedup requires a shared account, so two different people with one name stay apart. A stable "one contact per person" pick keeps answers consistent.

A job change fails the shared-account test by definition. The person's new record shares no account with the old one, so dedup correctly refuses to join them and leaves two records for one person.

A stable pick that ignores employment serves the old job. The oldest record, or any fixed key, is deterministic and tends to land on the employer the person left.

Electing the newest contact by created date tends to land on the current employer. Created date is still only a proxy for employment, so check it against a dated source where you can.

In a synthetic test set of 200 people, 60 of them job changers, electing the oldest record pointed all 60 at the employer they left. Electing the newest pointed none there, because in the set every new-employer record is the newer one. The set shows the mechanism, not how common it is.

Check your setup read-only

List the people with more than 1 CRM contact record. Take the 20 whose newest record was created most recently. Compare the account on the record your system picks with the account on their newest record. More than 2 of 20 where the pick points at the older employer means the pick rule ignores employment.

Passes if18 or more of 20 sampled people with several contact records resolve to the account on their newest record.

Access needed:crm-read

If it fails: changes to make later (not part of the check)
  1. 01Keep same-name dedup scoped to a shared account. Do not loosen the dedup scope to catch job changes.
  2. 02When one person has several contact records, pick the newest by created date, not the oldest or a fixed key.
  3. 03Track the share of picks that land on an account the person has left.
  4. 04Join records across accounts only on a second signal beyond the name.
Applies ifA job marks contacts departed or dedupes people across sources by name, and it serves 1 record per person to reps or agents.
TechniquecurrentRunning agents

Tool renames silently break agent skills and allowlists

Tool names change without aliases, so check the live list daily without a model.

SymptomA skill or agent prompt names a tool its MCP server no longer lists, and the step is skipped without an error.

When a tool server renames its tools with no aliases, each rename leaves skills, permission allowlists and a live agent's prompt teaching names that no longer exist, and the breakage is silent.

A daily check with no model now compares each server's live tool list with yesterday's snapshot and every hard-coded name. It stays quiet when healthy and alerts on three things:

  • A server dropped a name since yesterday.
  • A new stale reference appeared on a running surface.
  • A weekly probe can't load a referenced connector tool.

The Model Context Protocol specification defines a tools/list request that returns a server's current tool names, and an optional list-changed notification when that list changes.

Anthropic's platform moves too, so a second daily watcher reads only Anthropic's release notes and docs. Scripts drop items that share no vocabulary with what I run, and a small model labels the rest. Rewording is never a finding.

Each change is matched against three short registers I keep by hand:

  • Workarounds, each naming the upstream change that would retire it.
  • Deliberate deviations, each with what would make me revisit it.
  • Pain points, which outrank everything else.

The watcher proposes only. Each finding is evidence plus a ready patch or manual steps, a person applies it, and a rejection is appended to the register so the next run learns the no.

Check your setup read-only

List every tool name hard-coded in your skill files, prompt files and tool allowlists. Compare the list with the tool list each MCP server reports today. If a read-only session can't query a server, use the tool list the session already shows for the server. Any hard-coded name missing from its server's list is a gap.

Passes ifEvery hard-coded tool name appears in the current tool list of the server it names.

Access needed:local-config

If it fails: changes to make later (not part of the check)
  1. 01Collect every tool name hard-coded in skills, prompts, allowlists, routines and agent instructions into one list.
  2. 02Compare that list and yesterday's snapshot with each MCP server's live tool list each day, with no model.
  3. 03Alert only on a dropped name, a new stale reference on a running surface, or a failed weekly probe.
  4. 04Keep registers of workarounds, deliberate deviations and pain points. Match each upstream release note against the registers.
  5. 05Raise a finding against a deviation only if the change breaks that deviation's stated assumption.
Applies ifYour skill, prompt or allowlist files name tools from MCP servers or platforms that another party maintains.
FindingcurrentRunning agents

A tool's wording and defaults decide how wide the agent searches

Agents follow tool descriptions literally, including the loose parts.

SymptomAn agent searches wider than the question needs, beyond the account it names or back past the period it asks about.

A search tool's description tells the agent how to use it, so a line meant as a possibility, such as "you can also look at nearby items", reads to an agent as an instruction.

Agents take such lines as the default. They mix raw sources into searches that facts would answer, and widen scope beyond the account the question names.

Similarity search alone has no sense of time, so a phrase like last quarter becomes words to match instead of a date bound.

Results need to say what they are, too. An unlabelled near miss can do real damage, because an agent given only similar-name hits can conclude that an account it was asked about doesn't exist.

Check your setup read-only

Read the 20 most recent search-tool calls in your agent's transcripts. Count how many calls omit the account scope or mix raw sources with facts. More than 2 of 20 means the tool's defaults decide the width instead of the question.

Passes if18 or more of 20 sampled search-tool calls carry an account scope. The same calls carry only the source type the question asked for.

Access needed:agent-transcriptslocal-config

If it fails: changes to make later (not part of the check)
  1. 01Make the narrowest source type the default and wider sources an opt-in.
  2. 02Require the account scope on every call when the question names an account.
  3. 03Turn relative time in the question, such as last quarter, into explicit date bounds before searching.
  4. 04Label each hit with how it matched. Say when a hit is only a similar name.
  5. 05Reread every tool description for phrases an agent could take as a default.
Applies ifYour agent answers account questions for sellers through a search tool that can span accounts or mix raw sources with extracted facts.
FindingcurrentGTM data

Duplicate accounts make pipeline answers confident and incomplete

A corporate group spread across records and CRMs hides part of its pipeline.

SymptomA pipeline question about a large corporate group returns one confident total that leaves out deals on its sibling accounts, with no warning.

A large corporate group rarely lives on one account record. Unmerged duplicates and brands with their own domains split it up, and sometimes the group spans two CRMs run by different teams.

Domain matching does not join these records, since a group with many brands has many domains and nothing links them. A large CRM can have many duplicate-name groups. When asked about the group, an agent totals the account it found and reports it. That answer looks complete because it is complete for one record, yet it misses a material share of pipeline without saying so.

Group-level revenue has the opposite trap when revenue is reported once for the whole group. Copying it onto each member and then summing multiplies the total by the number of members, while splitting it invents per-account figures.

In a synthetic test set of 40 corporate groups, answering from the one record found missed 56% of the open pipeline; walking the group found all of it. The set shows the mechanism, not how common it is.

Flags and rollups leave duplicates in place rather than merging them at the source, so every answer is only as complete as those flags are current.

Check your setup read-only

Count the account names that appear on 2 or more account records across your CRMs. Take the 10 names with the most records. List the open opportunities on each record in those groups. Any group with open opportunities on more than 1 record means a single-account answer is incomplete.

Passes ifIn each of your 10 largest same-name groups, open opportunities sit on 1 record. Otherwise, parent links join the records your answers read.

Access needed:crm-read

If it fails: changes to make later (not part of the check)
  1. 01Flag every account that has a duplicate sibling in the same or another CRM. Show the flag to the agent.
  2. 02Let the agent walk parent and child links before answering a pipeline question about any account in a group.
  3. 03Define a group rollup for groups whose brands share no domain or parent link.
  4. 04Attach group-level revenue to each member as "one of N members". Never derive a per-account total from group-level revenue.
Applies ifYou route cards or answer pipeline questions per account, and your CRM holds parent-child accounts or you read 2 or more CRMs.
FindingcurrentGTM data

Placeholder values in required fields look like real data

Sentinels pass validation, then break blocking and blend into amounts.

SymptomA dedup or matching job slows sharply on one object, and its biggest block shares a placeholder name like "[not provided]".

Required fields get filled whether or not anyone knows the answer. An import that needs a last name writes "[not provided]", and an integration that needs an amount writes a template value.

Sentinel names wreck blocking. Dedup groups records by name before comparing pairs, so every record with the placeholder lands in one block, and pairs grow with its square.

Keeping sentinels out of the blocking keys makes the giant block go away, and intermediate rows fall by orders of magnitude.

Amounts are harder. A templated round number sits inside the real range, so no single value looks wrong. Only a cluster of identical amounts gives it away.

In a synthetic test set of 10,000 contacts, 1,000 of them carrying a placeholder name, blocking on name made 513,133 candidate pairs; excluding the placeholder left 13,633. The set shows the mechanism, not how common it is.

Check your setup read-only

List the 20 most frequent values in each required name field and each amount field. Any placeholder string is a sentinel your matching and math will read as real. A round amount far more common than its neighbours is also a sentinel.

Passes ifThe 20 most frequent values in each required name or amount field hold no placeholder and no outlying round amount. Otherwise, your matching excludes those values.

Access needed:crm-read

If it fails: changes to make later (not part of the check)
  1. 01Keep a per-field list of known placeholders, such as "[not provided]". Read listed placeholders as null.
  2. 02Exclude placeholder values, like nulls, from dedup blocking keys.
  3. 03Review any value in a field's 20 most frequent that has no plausible reason to repeat.
  4. 04Flag round amounts that repeat far more often than nearby values. Keep flagged amounts out of averages until reviewed.
Applies ifYour dedupe or enrichment matches people or accounts by name, or your digests average CRM amounts, and imports or integrations fill required fields.
FindingcurrentGTM data

One meeting can belong to several accounts

A single account field duplicates partner calls, and merging them loses all but one.

SymptomA partner or parent-and-subsidiary meeting appears twice, or on only one of the accounts it involved, and agents describe the linked account as attending.

The standard meeting record carries one account field. Partner calls and parent-and-subsidiary calls don't fit there, and neither do meetings with two customers.

The single field forces a choice. Sources pick different accounts, so the same meeting arrives as duplicates, and merging them keeps one account and drops the meeting from the rest.

Tool wording decides how an agent reads a meeting's account link. A loosely worded link can be read as attendance. A single wording change can lead an agent to state that the account's people attended a meeting that was only about the account.

The remedy is account membership per source, kept as separate links that survive merges, plus tool text that separates what a meeting is about from who attended.

In a synthetic test set of 150 two-account meetings, merging duplicates into one account field dropped every meeting from one of its accounts, 121 of them from an account whose people attended; keeping one link per source through the merge dropped none. The set shows the mechanism, not how common it is.

Check your setup read-only

List the 20 most recent meetings whose attendees come from 2 or more accounts. Count how many of those accounts show each meeting. More than 1 of 20 missing from an account its attendees belong to is a gap.

Passes if19 or more of 20 sampled multi-account meetings appear on every account their attendees belong to.

Access needed:crm-readcall-data

If it fails: changes to make later (not part of the check)
  1. 01Link a meeting to every account it involves, one link per source, instead of a single account field.
  2. 02Carry every account link through a merge, so merging duplicates never drops an account.
  3. 03Label the link in tool output as what the meeting is about. List attendees separately.
  4. 04Test each tool wording change over repeated agent runs. Count how often the agent states attendance it can't support.
Applies ifYou back-fill meetings or emails into the CRM against one account per activity, and you sell through partners or to groups whose people share calls.
TechniquecurrentGTM data

A late transcript turns one meeting into two

Match a late recording to its meeting by time and shared external attendees.

SymptomThe same call appears twice on an account timeline as a calendar meeting and a recording with a different title.

One meeting reaches a revenue team's data from several sources, such as the calendar, the call recorder and the CRM. Each carries its own title, and the transcript often lands after the meeting.

Titles don't match across sources, so a matcher keyed on title sees two meetings where there was one.

A time-window match with no other condition is the obvious first fix, but time alone over-merges back-to-back calls with different buyers into one meeting.

Shared external participants gate the time match. Two records in the same window count as one meeting only if they share an external participant.

A recorder row with no content doesn't prove the meeting was held. Until a transcript arrives, the calendar rule decides on whether the meeting started and was not cancelled.

In a synthetic test set of 300 meetings with 20 back-to-back pairs, a title match left every meeting duplicated, a time window alone made 20 false merges, and time plus a shared external participant made none of either. The set shows the mechanism, not how common it is.

Internal-only meetings have no external participant, so the gate can't apply to them, and a time match alone can't be trusted there.

Check your setup read-only

Take the account with the most meeting records in the last month. List its meeting records with start times and attendees. Find pairs that start close together and share an external attendee. Any pair that is really 1 meeting is a duplicate your matching missed.

Passes ifA candidate pair is 2 meeting records that start close together and share an external attendee. Among the sampled account's meetings from the last month, no candidate pair describes the same meeting.

Access needed:crm-readcall-data

If it fails: changes to make later (not part of the check)
  1. 01Match records of the same meeting on a time window, never on title.
  2. 02Require at least one shared external participant before a time match counts.
  3. 03Do not treat a recorder record with no content as proof the meeting was held. Use the calendar rule until a transcript arrives. The calendar rule asks whether the meeting started and was not cancelled.
  4. 04Attach a late transcript that matches to the existing meeting instead of adding a new meeting.
Applies ifYour jobs back-fill meetings or call activity into the CRM from both a calendar and a call recorder.
FindingcurrentGTM data

Date-only CRM activities land on the previous day

Because the CRM splits due date and time, parsing a bare date as midnight UTC lands it on the previous evening.

SymptomActivities logged with a date but no time show on the day before in timelines viewed from the Americas. A reply also sorts below its own quoted copy.

CRMs often store an activity's due date and its time as separate fields, and the time is optional. Combining them into one timestamp is the standard move, and parsers such as JavaScript's Date read a bare date as midnight UTC.

Midnight UTC falls on the previous evening across the Americas, so a call logged for Tuesday with no time renders on Monday evening. Salesforce's Event object reference says ActivityDate holds the due date of an all-day event with a timestamp always set to midnight UTC, while ActivityDateTime holds the time for events that are not all-day.

Ordering breaks too. A date-only reply sorts below the quoted copy of it that arrived with a real time, so the thread reads backwards.

Date-only activities can be common enough to skew time-of-day metrics.

The remedy is to keep date and time separate, with a "time unknown" flag.

In a synthetic test set of 500 activities, 100 of them date-only, converting to Los Angeles time put all 100 on the previous day; keeping them as dates put none there. The set shows the mechanism, not how common it is.

Check your setup read-only

Count CRM activities flagged as date-only. A date-only activity is a task's due date with no time, or an all-day event. Compare the date-only activities with the activities that carry an explicit time. Take the 10 most recent date-only activities. Find each one in your timeline and metric output. Any date-only activity shown with a time of day, or on the previous day, is a gap.

Passes ifActivities flagged as date-only show as date-only in your timelines and metrics. No date-only activity shows with a time of day or on the previous day.

Access needed:crm-read

If it fails: changes to make later (not part of the check)
  1. 01Store an activity's date and time separately, with a flag when the time is unknown.
  2. 02Display a date-only activity as a date with no time zone shift, never as midnight UTC.
  3. 03Rank an activity's own recorded time above any fallback time when sorting.
  4. 04Count date-only activities per source before trusting any time-of-day metric.
Applies ifYou back-fill email activity as CRM tasks, or build timelines and response-time metrics from tasks and events across time zones.
TechniquecurrentRunning agents

When you remove the human gate, name what replaced it

Going hands-off takes named compensating checks and a written dial-back trigger.

SymptomAgent output that used to wait as proposed now lands live, and no log shows a check holding anything back.

A target list that gains entries daily from an unattended research agent was designed to stage them as proposed for me to ratify.

Taking the ratify step out means the safety has to move into deterministic gates first.

  • A dated source must show the person holds the role now, or the account component scores zero.
  • Every non-zero score component points to a sourced evidence item.
  • Gold rows are graded with each batch, and a calibration fail holds the whole batch.
  • Each run commits locally before it publishes so any published file is one revert away, while external writes need their own reversal snapshot.

The dial-back trigger is written down. One bad unattended record sends new entries back to proposed.

The gold rows can't go stale either. They rotate per session by a salt, and a row that fails in two sessions of a run is quarantined instead of holding everything. A quarantined gold row goes to a person before the next run.

A veto window must not ambush old proposals. Tier changes later got a 48-hour window that opens at the first live run, so proposals that predate the switch never confirm unseen.

Check your setup read-only

Find each agent step in your job configs that no longer waits for a person. Name the check that replaced the review for each step. Find the last hold that the check recorded in the run logs. A hold is a run-log line where the check stopped or held back at least one record. A step with no named check, or one whose check has no hold in the run logs, is a gap.

Passes ifEvery unreviewed step names the check that replaced review. Each check shows at least one recorded hold in the run logs.

Access needed:schedulerlocal-config

If it fails: changes to make later (not part of the check)
  1. 01List the checks that replace a review step, and how each check fails, before you remove the step.
  2. 02Grade rotating gold rows with every batch. Hold the batch on a calibration fail.
  3. 03Quarantine a gold row that fails in 2 sessions of one run. Do not hold all output for that row. Route the row to a person before the next run.
  4. 04Commit each run before publishing so any published file can be reverted. Snapshot external writes separately so they can be reversed.
  5. 05Start a veto window at the first live run, never at the proposal's creation date.
Applies ifA job config in your setup writes agent-researched records to a list or the CRM with no approval step by a person.
TechniquecurrentGTM data

Attribution captured at ingest goes stale when the CRM changes

CRMs re-parent records after you read them, so recheck each account link.

SymptomA call or email is missing from the right account's timeline after someone moved its CRM task or opened a new account for that company.

A typical ingest pipeline assigns each call or email an account when it arrives, and because the CRM keeps moving, that account can change after you read it.

Account attribution is a moving value on a record. Whenever a rep re-parents a task to the right account, or an account is opened weeks after the first calls with that company, the source changes while the copy taken at ingest stays put.

Derived data inherits the stale link. Facts extracted from a misattributed call stay scoped to the old account, so an agent answering about either account works from the wrong evidence.

Correcting the link once does not hold when a thread is processed again, because older messages can carry the old account back onto one that was already corrected.

In a synthetic test set of 500 emails, keeping the account stored at ingest left 218 emails and 444 facts on the wrong account; taking each message's account from its own task at read time left none. The set shows the mechanism, not how common it is.

Check your setup read-only

Take the 10 most recent calls or emails linked to an account more than 1 month ago. Compare each stored account with the account its source record names in the CRM today. Any mismatch means attribution is frozen at ingest.

Passes ifAll 10 sampled calls or emails still carry the account their CRM source record names today.

Access needed:context-readcrm-read

If it fails: changes to make later (not part of the check)
  1. 01Store the source record's id with every call, email and fact, not only the account it resolved to.
  2. 02Re-join every signal to its source's current account at least weekly. Rebuild anything scoped to the account.
  3. 03Move the call or email to the new account when its CRM task is re-parented. Invalidate the facts scoped to the old account.
  4. 04Take a thread's account from its current source records, never from a link stored on an earlier message.
Applies ifYour store keeps account ids on calls or emails, and the CRM's field history shows reps re-parenting contacts, tasks or accounts.
FindingcurrentGTM data

Eval answer keys over CRM data go stale

When the CRM moves, a benchmark failure can mean the expected answer is wrong.

SymptomBenchmark failures where the agent's answer matches the CRM today but not the expected answer written weeks earlier.

An eval for agents on revenue data pins expected answers to a CRM that keeps moving. The expected answer was right on the day it was written.

Benchmark failures on CRM data can come from stale anchors. The CRM genuinely changed, so the agent was right and the answer key was wrong.

Counting those as failures drops the score for no model reason, and tuning against that score pushes the agent toward last month's data.

Every expected answer is a fact with a date.

Check your setup read-only

Take the 10 most recent failures from your saved eval questions. Compare each expected answer with the current CRM value. More than 1 of 10 where the agent matches the current CRM means the answer keys are stale. The model is not the cause.

Passes ifAt most 1 of 10 sampled recent eval failures has the agent matching the current CRM value.

Access needed:local-configcrm-read

If it fails: changes to make later (not part of the check)
  1. 01Store the date each expected answer was written, with the records it depends on.
  2. 02Compare the expected answer with the current CRM value before scoring a failure.
  3. 03Label failures where the agent matches the current CRM as stale anchors. Keep stale anchors out of the model's score.
  4. 04Refresh or retire stale anchors on every benchmark run, not ad hoc.
Applies ifYour eval folder holds a saved set of expected CRM answers, such as account owners or employers, reused over weeks.
FindingcurrentRunning agents

A stated reason is a hypothesis rather than a rule

Turning a reviewer's stated reasons into a filter threw out good accounts.

SymptomAn exclusion rule in your target list traces back to one person's explanations of their no's, with no outcome data behind it.

A seller reviewed a batch of our target accounts and disqualified several, with a reason for each. My analysis read the reasons as rules.

More than a third of the no's shared one firmographic attribute, so the analysis turned that attribute into a penalty. A back-test agreed, because it ran on the same verdicts the rule came from.

The filter then removed about twice as many accounts as the seller had rejected, none of them researched.

The reason had the cause wrong. Those no's shared a passing business condition rather than a fixed attribute. The removed accounts were re-screened and recovered.

Now a verdict and its stated reason are separate records. The reason is a hypothesis with a confidence, never a rule.

Until outcomes can test a rule, I don't mine rules. A new candidate shows the 3 most similar past verdicts beside it, and a person judges.

Check your setup read-only

List each exclusion rule in your target-list scoring config. An account with a known opposite verdict is one the rule excludes whose CRM opportunity closed won. It is also one the rule keeps whose opportunity closed lost. Look for a stored test that scores each rule against such accounts. A stored test is a script, its output or a doc. The test must use accounts that weren't used to derive the rule. Any rule with no such test is a gap.

Passes ifEvery exclusion rule was scored against accounts with a known opposite verdict that weren't used to derive it.

Access needed:local-configcrm-read

If it fails: changes to make later (not part of the check)
  1. 01Store each verdict and its stated reason as separate records.
  2. 02Do not mine rules until outcomes, not opinions, can test the rules. Show the 3 most similar past verdicts beside a new candidate until then.
  3. 03Score the accounts a rule would touch against their recorded verdicts before the rule surfaces.
  4. 04Do not back-test a rule on the verdicts it was derived from.
  5. 05Let rules down-rank with a visible reason, never remove. Let anyone challenge a rule back into review.
Applies ifYour scoring config takes reviewer verdicts as input, and fewer than a few hundred accounts carry a verdict.
FindingcurrentGTM data

Long-open cases fall outside recency windows

Keep a record if it's recent or still open.

SymptomAn agent can't find a support case the customer is still waiting on, because the case was opened before your ingest cutoff.

A recency window is the standard cost control for ingest: load the last N months and skip the rest. For most objects, old means finished.

Open support cases don't follow that, because the backlog can skew old and leave many open cases older than a 12-month cutoff. The risk is greatest for a window on created date, or on cases nobody has touched inside it.

Those are the cases people ask about, yet a 12-month window can drop much of the open support work while keeping the recently closed cases, so the rule is recent or still open.

Check your setup read-only

Count open support cases by the date each case was opened. Find the share older than the cutoff in your ingest or retrieval config. Any open case outside the window is live work the window drops.

Passes ifNo open support case is older than your ingest or retrieval cutoff. Otherwise, your jobs keep open cases regardless of age.

Access needed:crm-readlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Keep a record if it was modified inside the window or is still open, whatever its age.
  2. 02Define open per object from its status field, such as not closed and not resolved.
  3. 03Apply the same rule to any object with long-lived open states, such as support cases and opportunities.
  4. 04Count open records older than a cutoff before choosing the cutoff. If that share is material, widen the rule, not the window.
Applies ifYour ingest or retrieval config reads only recent CRM records, cases or activity, and customer-health views or alerts rest on them.
TechniquecurrentRunning agents

A dashboard should show when its data was last built

When the job behind a page dies, the page itself should say so.

SymptomA dashboard renders normally while one of its feeding jobs has not logged a run in days.

My target-list page is built from several feeding jobs. When one dies, the page keeps rendering the last good data, and nothing on it looks wrong.

The page now stamps its own age where sellers already look.

  • When the page itself was built.
  • The heartbeat age of each lane that feeds it, red past its threshold.
  • Each queued action's expiry, so one nobody picked up says "act manually".

Liveness can't travel only over the channel whose death it reports. A dead job can't raise its own Slack alarm, and a reviewer who skips the alerts channel never sees it anyway.

Silence also has to look different from no news. A job that ran and found nothing still writes a heartbeat. A job that never ran writes nothing, so its age climbs on the page.

The expiry matters most for actions, because without it an unclaimed action sits behind a live-looking button that does nothing.

Check your setup read-only

Open each seller dashboard that 2 or more scheduled jobs feed. Look on the page for its build time and each feeding job's last run time. Compare those times with the scheduler's run log. If either time is missing from the page, that's a gap.

Passes ifEach such dashboard shows its build time and each feeding job's last run time. Both match the scheduler's run log.

Access needed:schedulerlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Stamp the page's build time on the page itself.
  2. 02Show each feeding job's last heartbeat beside it, red once it is older than that job's expected cadence.
  3. 03Have every job write a heartbeat each time it runs, including runs that found nothing.
  4. 04Give every action queued from the page an expiry, and render expired ones as "not picked up, act manually".
Applies ifA dashboard or page that sellers read is built from the output of 2 or more scheduled jobs.
TechniquecurrentRunning agents

A cost fix that cuts coverage changes what the job does

I split token fixes by what they can break instead of what they save.

SymptomA job's token use dropped after an efficiency pass, and its output count dropped with it.

My token-waste review proposes fixes. At first every fix waited for my approval, and approving every fix trains me to stamp them. Skipping approval lets an efficiency change quietly change what a job does.

On one review, 2 of the 8 proposed fixes looked like savings and were really changes to what the job covered.

In a second case, a rewrite of a nightly enrichment job used about a fifteenth of the old version's tokens on one run.

It also found about a third fewer people than the old version, and that count, not the token count, decides whether such a rewrite ships.

The lost people sat on older email threads that had been re-ingested. Their activity dates fell outside the window the cheaper query filtered on. The job feeds the CRM, so the saving meant fewer records reached it.

So fixes now split by blast radius, and the split decides whether I look before a fix lands.

For auto-applied fixes, a clean record on work written minutes earlier is the easy case. It says little about older work, or someone else's. When an auto-applied fix turns out wrong, shrink the auto-apply list rather than going back to asking on everything.

Check your setup read-only

List the jobs whose git log shows a cost cut in the last 90 days. Read each job's run log. Compare its output and input counts for the week before and the week after the cut. Any output drop the inputs don't explain means the cut reduced coverage, and that's a gap.

Passes ifOutput counts after the cut move with input counts, inside the job's usual week-to-week range.

Access needed:schedulerlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Apply behaviour-preserving fixes without asking. Behaviour-preserving fixes include deduplicated prompt text, prompt caching, and a pointer instead of a restated doc. Output bounds that don't truncate results are also behaviour-preserving.
  2. 02Ask before any fix that changes coverage. Coverage fixes include kill criteria, abort thresholds and dropped inputs. Coverage fixes also include a collapsed or serialized fan-out and batching units into fewer agents.
  3. 03Ask before downgrading the model on a stage that needs judgment.
  4. 04Compare output counts before and after every cost fix, not only tokens.
  5. 05Report every applied fix with its checklist number, even when nothing needed approval.
Applies ifYour git log shows a cost cut to a job that writes CRM records or feeds a list.
FindingcurrentRunning agents

Asking a headless agent to read less didn't hold

Changing the schedule held my token limit when instructions in the prompt did not.

SymptomA scheduled agent's prompt says to stop at a watermark, and its transcript shows it paging past it.

A nightly enrichment job of mine read a lot of email and meeting data, and its usage was crowding other jobs out of the shared token budget. I tried to make it read less.

I started with prose. The prompt said to stop at the watermark and not to open full threads.

The headless run ignored both.

It paged blindly through hundreds of emails and meetings, opened 19 full records, and timed out after more than a hundred turns, with no output.

Next I tried a short tool allowlist that left the agent a listing call and little else. An allowlist names the tools that run without a prompt rather than locking everything else out. The allowlist held once, then swung:

  • First run: about a tenth of the original's tokens.
  • Same prompt, allowlist and window again: eight times the first run.
  • Both covered fewer people than the original version.

A job that writes to the CRM can't ship on an 8x swing.

Changing the cadence held. One heavy job went from daily to Monday, Wednesday and Friday, the other to alternate days.

Idle time follows the same split. A watcher with a mechanical trigger runs as a plain process at zero inference and summons a disposable model only when the trigger fires.

Check your setup read-only

Take the run with the most tokens among the last 10 runs of each scheduled agent job. Read its transcript beside its prompt file. Count the tool calls the prompt told the run not to make. One or more means the prompt isn't holding the limit.

Passes ifNo sampled run's transcript shows a tool call that its prompt excluded.

Access needed:agent-transcriptslocal-config

If it fails: changes to make later (not part of the check)
  1. 01Enforce read limits in code: a turn cap, a call cap, or inputs pulled before the model starts. An allowlist shapes which tools run, not how much they read.
  2. 02Run the same headless prompt at least twice and compare token use before trusting either number.
  3. 03Cut a job's cadence when its cost still won't come down: daily to 3 days a week, or alternate days.
  4. 04Run watchers with a mechanical trigger as plain processes. Start a model only when the trigger fires.
Applies ifA scheduled headless agent's prompt file tells it to stop reading at a limit, such as a watermark or a page count.
TechniquecurrentRunning agents

Compute a fact's age when it's shown instead of in a refresh job

Badges computed at render time keep moving after every refresh job stops.

SymptomA seller-facing page shows a fact as current long after its source changed, such as a contact's old role with no date beside it.

I keep a living list of the people we target at our best-fit accounts. My first design refreshed it on a schedule and pushed a digest of proposed changes to me as the one reviewer. Digests like that outran me and were dead within days.

Staleness is now computed from each fact's last-verified date when the page renders, so no job has to run for a badge to move. Sellers still see amber and red on pages they already use even if every watcher dies.

  • A person's role goes stale after about 90 days.
  • A company-level judgment goes stale after about 180 days.
  • A buy signal goes stale after about 30 days.

Each judgment is also split by half-life, because leaving a decaying signal inside the score reshuffles the list every run and serves week-old "hot" flags as current. A structural fit read changes over quarters and ranks the list, while a timing read decays in weeks and shows only as a dated note after selection.

Moving proposals from a push digest to a pull queue turned two ignored weeks from archaeology into a 20-minute triage.

These windows are judgment calls rather than measured rates of how fast each kind of fact goes wrong, so treat them as starting points.

Check your setup read-only

Open the seller-facing account page for any 1 account. Read the first 10 facts on the page. Look for a last-verified date shown beside each fact. More than 2 of 10 without a visible date is a gap, because the page can't show its age.

Passes if8 or more of 10 sampled facts show a last-verified date on the page itself.

Access needed:local-config

If it fails: changes to make later (not part of the check)
  1. 01Store a last-verified date on every fact you display. Compute the fact's age at render time.
  2. 02Mark a role fact stale after about 90 days. Mark a company-level judgment stale after about 180 days. Mark a buy signal stale after about 30 days.
  3. 03Rank only on durable signals, cached per rubric version. Show timing signals as dated notes after selection.
  4. 04Let a newer proposal about the same entity and field supersede the older one.
  5. 05Expire low-impact proposals visibly, with a count of what expired unreviewed.
Applies ifOne person approves changes to a list the page shows, and the approval log shows gaps of several days between reviews.
FindingcurrentGTM data

Archiving a duplicate makes it look fresher to last-writer-wins

Archiving can bump the modified time, which makes last-writer-wins pick the retired record.

SymptomAfter a duplicate cleanup, a merged entity shows values from the archived copy rather than the active record.

When two source records describe the same entity, a merge has to pick a value per field. Letting the most recently modified record win is the natural first choice, and that textbook rule holds up until the first duplicate cleanup.

In a CRM, deleting or archiving a record is an edit that can bump its modified time like any other change. Because this behavior depends on the CRM, run the check below before relying on either rule.

When someone archives a duplicate to retire it, that action can make it the freshest record in the set and invert last-writer-wins, letting its old values beat the active record's. This happens when reading the source's own modified time, though a warehouse copy may not move that timestamp on archive.

Rank by status first instead, per field:

  • Active records beat archived ones.
  • Modified time, read from the source, decides among records with the same status.
  • The older created date breaks a modified-time tie, since the original record is usually the one kept.

Equal timestamps also need their own rule, so a deleted record never comes back because its timestamp ties a live one.

In a synthetic test set of 200 people, 20 with an archived duplicate whose archive bumped its modified time, last-writer-wins took the archived copy's value for 44 fields; ranking by status first took none. The set shows the mechanism, not how common it is.

Check your setup read-only

Take the 10 most recently merged entities built from 2 or more source records where 1 record is archived. Look at which record supplied each field. Look for fields that came from the archived record while the active record had a value. Any such field means the tiebreak favors archived data.

Passes ifIn all 10 sampled entities, every field with a value on the active record came from the active record.

Access needed:context-readcrm-read

If it fails: changes to make later (not part of the check)
  1. 01Choose each value per field, not per record.
  2. 02Rank by active status first, then by modified time read from the source. Use the older created date only to break a modified-time tie.
  3. 03Treat an archive or delete as a status that lowers a record's rank, not as a fresh edit.
  4. 04Keep a deleted record deleted when the timestamps are equal.
Applies ifYour dedupe or enrichment config merges contact or account records from several systems and breaks ties by the most recent modified time.
FindingcurrentGTM data

An email domain does not prove which company someone works for

Subsidiaries, agencies and observers break the standard domain-to-account match.

SymptomA meeting lands on the wrong account because one attendee's email domain is another account's domain, and agents then name the wrong company.

Matching a person to a company by email domain is the standard first move. It builds a domain list per account from the CRM website, contacts and meeting attendees.

An email domain is evidence rather than an answer, because some accounts hold a contact whose domain is another account's primary domain.

  • A subsidiary or sister brand filed under the parent.
  • An agency or partner employee logged as a contact.
  • An observer who sits in on meetings across two or three accounts.
  • A contact filed under the wrong account by hand.

A count threshold clears single-contact noise. A bigger threshold will not settle what remains, because those cases ask a question about the company and need adjudication.

In a synthetic test set of 2,000 contacts, 40 carried a domain that is another account's primary domain. A domain join filed all 40 to the wrong account; trusting an explicit account link first left 6, the ones with no link. The set shows the mechanism, not how common it is.

Check your setup read-only

List the contact email domains per account in the CRM. Count the accounts where a contact's domain is another account's primary domain. Any such account can misfile a meeting. 5% of accounts or more means domain matching can't be your only rule.

Passes ifUnder 5% of accounts hold a contact whose email domain is another account's primary domain. Your matching has a rule beyond domain for those accounts.

Access needed:crm-read

If it fails: changes to make later (not part of the check)
  1. 01Keep one domain registry that every consumer reads, instead of each job deriving its own domain list.
  2. 02Drop domains seen on only one contact before judging the rest.
  3. 03Have a person or a model adjudicate each candidate domain against the account. Treat human overrides as final.
  4. 04Re-check an account only when its evidence changes.
  5. 05Compare a new matcher's output with the current one before switching.
Applies ifA job matches people, emails or meetings to accounts by email domain, and the CRM holds more than a few hundred accounts.
FindingcurrentRunning agents

A sub-agent has a fixed token cost, so small work is cheaper inline

In my setup each sub-agent paid 70 to 85k tokens before it did any work.

SymptomA fan-out of one sub-agent per small task costs far more tokens than the tasks' tool calls explain.

Each sub-agent starts by loading its base instructions, tool schemas and orientation. I measured that at about 70 to 85k tokens per agent, whatever the task size.

I had been dispatching one agent per file to republish pages, about two tool calls of real work each.

Batching 5 to 9 files per agent took a round from about 600 to 900k tokens to about 160 to 255k. Reliability held, because the return contract kept one result line per file.

If the repeat is deterministic, like a regex-safe edit across files, it shouldn't be an agent at all.

Resuming a finished agent is cheaper still, because it keeps its warm context and costs no new spawn.

That breaks down when files on disk have changed since the agent read them.

A drafter I resumed through two rounds of template and voice edits held the old versions in context and blended them with the new. Its output looked compliant while missing the edits, so the final run went to a fresh agent.

That resume-or-respawn call depends on knowing which files an agent read, so that list needs a record outside the orchestrator's head.

Check your setup read-only

Take the most recent session that spawned 5 or more sub-agents for the same kind of task. List each sub-agent's total tokens beside the tool calls it made on the task itself. Any sub-agent with tens of thousands of tokens on 2 or 3 task calls should have been batched or scripted.

Passes ifNo sub-agent in the sampled session spent tens of thousands of tokens on 2 or 3 task calls.

Access needed:agent-transcripts

If it fails: changes to make later (not part of the check)
  1. 01Batch mechanical repeats 5 to 10 per agent, with one result line per unit in the return contract.
  2. 02Script any repeat that is deterministic instead of dispatching an agent.
  3. 03Resume a finished agent when the inputs are new and the files it read are unchanged.
  4. 04Respawn a fresh agent once its contract files changed. Name the changed files for re-reading in the resume message when only 1 or 2 changed.
Applies ifYour transcripts show sessions that spawn several sub-agents for small repeated tasks, or reuse one agent across rounds.
FindingcurrentGTM data

A rep-entered profile URL beats a vendor's perfect-score match

Enrichment can return a different person even when name and company scores are perfect.

SymptomAn enriched contact shows another person's profile or title even though the CRM already held the right profile URL.

The standard enrichment flow trusts a vendor match whenever its name and company scores are high, treating a perfect score like proof.

A perfect score can still be a different person. Name and company are what the vendor matched on, so two people with one name at one company can both score perfectly.

Profile slugs also change when people rename their public profile URL, so an old URL in the CRM and a new one from the vendor can be the same person.

So let the human-entered URL win, because someone chose it on purpose. The vendor should fill only the gaps, with every disagreement logged and reviewed on a schedule. Adopt a new slug only when the vendor supplies a stable id that ties both URLs to the same person. Otherwise the CRM's URL stays.

In a synthetic test set of contacts with rep-entered profile URLs, letting a perfect-score vendor match win overwrote the correct URL on 5 of 10 namesake contacts; keeping the rep-entered URL overwrote none and logged 5 disagreements for review. The set shows the mechanism, not how common it is.

Check your setup read-only

List contacts that hold a profile URL both in a rep-entered CRM field and from enrichment. Count the contacts where the 2 URLs differ. Any difference where the enriched URL is the one in use is a possible wrong person.

Passes ifWherever the rep-entered and enriched profile URLs differ, the rep-entered one is the URL your jobs and agents read.

Access needed:crm-read

If it fails: changes to make later (not part of the check)
  1. 01Treat a profile URL entered in the CRM as the identity anchor. Let enrichment fill only empty fields.
  2. 02Log every case where the vendor's profile differs from the CRM's, instead of choosing silently. Review logged disagreements on a schedule.
  3. 03Adopt a new profile slug only when a stable id from the vendor ties both URLs to the same person. Otherwise, log the disagreement. Then keep the CRM's URL.
  4. 04Never let a match score override a human-entered identifier, however high the score.
Applies ifA job enriches titles or departures from a vendor, and a rep-entered CRM field holds profile URLs for some contacts.
FindingcurrentGTM data

Call transcripts name the speaker without giving their side

Guessing a speaker's side flips the meaning of "we" in a call summary.

SymptomA call fact credits the customer with a line the seller said, or gives a next step to the wrong company. The quoted words are correct.

Most conferencing tools don't send speaker side. Recorders that do derive it from email domain, so treat it as one input rather than the answer. A summarizer that writes "we agreed" or "they asked" has to decide whose "we" it is.

Side has to be derived from the person the speaker resolves to. That person is an internal user, a contact at the account, or nobody known. Gong's API reference lists each call party's affiliation as Internal, External or Unknown, and ties transcript speakers to parties through a speaker ID.

When side is guessed wrong, the verbatim quote stays right while the summary sentence around it hands those words to the other company.

Repair carries the same risk as the original error. A naive repair can flip facts to the wrong side.

Unknown is a better answer than a confident wrong side.

In a synthetic test set of call transcripts with 25 unresolved speakers, defaulting unresolved speakers to external filed 104 internal statements as customer-said; resolving each speaker first filed none and left 193 statements marked unknown. The set shows the mechanism, not how common it is.

Check your setup read-only

Take the 10 most recent call facts in your fact store that say "we" or assign a next step. Find each speaker's side: your side if the speaker's email domain is your company's domain, the customer's side if not. With no email, use the account on the speaker's CRM contact record. Compare that side with the side the fact gives the speaker. More than 1 of 10 that differ means sides are being guessed.

Passes ifIn 9 or more of 10 sampled call facts, the speaker's side matches their email domain or CRM contact record.

Access needed:context-readcall-datacrm-read

If it fails: changes to make later (not part of the check)
  1. 01Resolve each speaker to a person first. Derive the side from that person: internal user, account contact, or unknown. Use any side label a recorder sends as one input, not the answer.
  2. 02Decide the side before the model generates the summary sentence. Give the side to the model alongside the quote.
  3. 03When a speaker can't be resolved, label the side unknown instead of defaulting to external.
  4. 04Recompute the side of old facts with the same rule the extractor applies to new facts. Rewrite only the facts whose side differs.
Applies ifYour fact store or signal cards draw on call summaries from 2 or more recording or conferencing tools, attributed to companies.
FindingcurrentGTM data

A recurring meeting's join id names the series rather than a single meeting

Because a weekly call reuses one join id, every week's transcript lands on one meeting record.

SymptomOne meeting record holds transcripts from several different weeks, or a weekly series shows as a single meeting.

Keying meetings on the conferencing join id is the standard move because that id appears in both the invite and the recording.

In a recurring meeting, though, the join id belongs to the series. Zoom's support article on scheduling a recurring meeting says each occurrence of a recurring meeting uses the same meeting ID and settings. Because every occurrence reuses that id, a single weekly call's meeting record keyed on the join id alone can quietly collect every week's transcripts, leaving a summary of the meeting to read months of calls as one.

So identity is the join id plus the occurrence's scheduled start time, or the platform's occurrence id where it has one. Match each recording to the nearest scheduled occurrence, within half the series interval. A personal-room link is not a meeting id at all.

In a synthetic test set with one weekly series over 12 weeks, keying on the join id alone put all 12 transcripts on one meeting record; adding the scheduled start left one on each. The set shows the mechanism, not how common it is.

Check your setup read-only

Count recordings or transcripts per meeting record. List the records with more than 1. Match each recording's start time to the series' scheduled occurrences. Recordings from different occurrences under 1 record mean the id names a series.

Passes ifEvery meeting record with more than one recording or transcript has all of them matched to the same scheduled occurrence.

Access needed:call-data

If it fails: changes to make later (not part of the check)
  1. 01Key meeting identity on the join id plus the occurrence's scheduled start time, not the join id alone.
  2. 02Never key on a personal-room link alone. A personal-room link is not a meeting id.
  3. 03Prefer the platform's occurrence id when the platform has one. Otherwise, attach a recording to the nearest scheduled occurrence within half the series interval.
  4. 04Count records holding recordings from more than one occurrence as a standing check.
Applies ifYou back-fill call recordings or transcripts onto CRM or calendar meeting records by matching on join link or meeting id.
FindingcurrentGTM data

A shared first name sends the seller's words to the buyer

First-name matching is safe only inside the account, and the rep isn't in it.

SymptomA quote from your own rep can be attributed to a buyer-side contact with the same first name. The account summary then says the customer said it.

Transcripts and notes often name speakers by first name only. Scoping a first-name match to the account's members is the standard way to make it safe.

The scope fails because the vendor's rep is on the call but is not a member of the customer account. When your rep Dana speaks, the buyer named Dana is the only Dana in scope.

Then the seller's words can become the buyer's. Pitch lines, pricing and next steps can read as customer statements, and agents repeat them as the customer's view.

The remedy is to promote a bare first name using the quote's full speaker name when the transcript has one. Look outside the account only when the full name is a unique match, and let a vendor-side participant with the same first name lower the confidence.

In a synthetic test set of calls where reps and buyers share first names, account-scoped matching attributed 112 of 389 rep quotes to a buyer; full-name promotion plus a vendor-side name check attributed none and left 189 quotes unresolved. The set shows the mechanism, not how common it is.

Check your setup read-only

List the 20 most recent quotes resolved to a contact from a first name only. Search each call's participant list for a vendor-side speaker with the quote's first name. A vendor-side speaker is a participant whose email domain is your company's domain. Any match is a quote that may sit on the wrong side.

Passes ifNone of 20 sampled first-name-only quotes shares its first name with a vendor-side participant on the same call.

Access needed:call-datacrm-readcontext-read

If it fails: changes to make later (not part of the check)
  1. 01Resolve a bare first name from the full speaker name on the same quote or call. Fall back to account scope only after that step.
  2. 02Look outside the account only when the full name matches exactly one person.
  3. 03Check the call's vendor-side participants for the same first name. Lower confidence or leave the quote unresolved when a vendor-side participant matches.
Applies ifA job attaches call quotes to CRM contacts from speaker names, or matches people across sources by name.
FindingcurrentGTM data

The account owner of record is not always a working book

CRMs keep ownership on inactive users and park accounts on a default owner.

Symptom"My accounts" or "top AE by accounts" answers include people who have left, or a default user holding a large share of accounts.

Agents answer "my accounts" and "who covers this" from the account owner field. That is the standard reading, but the CRM doesn't keep the field current.

CRMs leave accounts on users after they're deactivated, and unassigned accounts get parked on a default owner. Neither is a working book. Salesforce Help's page on deactivating users advises transferring a deactivated user's records to an active user, because processes can't update records owned by inactive users.

So answers built on the field mislead. A "top AE" ranking can crown the parking user, and "my accounts" includes accounts nobody works.

Show the agent whether each person is active, and a last-interaction date on each stakeholder link, so it can tell an owner from someone working the account.

An owner-only reading also misses the deal team, which often sits in custom user-lookup fields instead of the owner field.

In a synthetic test set of CRM accounts, ranking owners by account count put a default owner first with 150 accounts, 2.7 times the top active rep's 55; leaving out inactive and default owners put an active rep first. The set shows the mechanism, not how common it is.

Check your setup read-only

Count accounts per owner on the account object. Compare each owner with the CRM user object's active flag. Count the accounts held by a single default owner. Any such account that your routing or owner-based answers treat as a working book is a gap.

Passes ifYour routing and owner-based answers skip or flag every account that an inactive user or a default owner holds.

Access needed:crm-readlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Check the owner's active status before treating an owner as a working rep.
  2. 02Leave default or placeholder owners out of rankings and "my accounts" answers.
  3. 03Show a last-interaction date beside each owner or stakeholder link.
  4. 04Read the custom user-lookup fields for the deal team, not only the owner field.
Applies ifYou route alerts or tasks to sellers by the CRM account owner, or agents answer coverage questions from that field.
FindingcurrentRunning agents

A finding written in a doc doesn't change the system

A finding has not landed unless you can name the executable line it changed.

SymptomA lesson already written in a process doc's notes gets rediscovered, while the doc's scoring step is unchanged.

My account-selection process had a pain-points section. Early in the year it recorded a clear insight about which kinds of accounts fit best.

Five months later I derived the same profile from scratch, because the finding never reached the line the process runs.

Its scoring still weighted a signal that pushed exactly those accounts down, and every quarterly run repeated the miss.

The step now calls my shared fit rubric instead of hand-rolling its own scores. A rubric edit reaches every run the same day, because the rubric is the mechanism.

The reverse direction drifts too. When I retired three holds from a daily sweep, four prose copies kept describing them as live:

  • the runbook
  • the root instructions file
  • a memory note
  • the script's own header comment

Anyone reading those trusted a net that no longer existed, and agents read the same docs.

Check your setup read-only

Take the 5 newest lessons in each process doc's notes or pain-points section. Search the scoring rubric, filter or gate code that the process runs for a line that encodes each lesson. A line encodes a lesson if it names the same field, value, threshold or condition the lesson names. More than 1 of 5 with no such line is a gap.

Passes if4 or more of 5 sampled lessons per doc map to a scoring, filter or gate line. Each line is in the code or rubric the process runs.

Access needed:local-config

If it fails: changes to make later (not part of the check)
  1. 01Name the scoring, filter or gate line a finding changed, after you land the finding. A finding that changed no such line has not landed.
  2. 02Replace hand-rolled scoring inside a process with a call to the shared rubric.
  3. 03Search docs, instructions, memory and script comments for the old phrasing when a gate or threshold changes in code. Do the search in the same session as the change.
  4. 04Correct every restatement you find before you call the change done.
  5. 05Close the old documented findings that a changed mechanism now resolves.
Applies ifYour setup has process docs with a notes or pain-points section, kept apart from the code or rubric the process runs.
FindingcurrentRunning agents

Agent cost is turns times context rather than payload size

Most of a 9M-token run went to cache reads, with turns and coverage setting the bill.

SymptomA multi-agent run reports millions of tokens, while its tool results add up to a few hundred KB.

A nightly job I run researches buying committees with a fan-out of dozens of agents. Its usage report said about 9M tokens. The output it generated was a small fraction of that.

Most of the headline was cache reads, with each agent re-reading its own growing context every turn.

Anthropic's prompt caching documentation prices cache reads at a tenth of base input, lower for some models, so the dollar cost sits far below the headline. My token budget counts them all the same.

The heaviest agent ran 124 turns while its context grew from 62k to 235k tokens. Its tool payloads came to 160 KB in total.

So cost is turns times context per turn, per agent. In an 88-turn run, a 13k-token result landing at turn 30 gets re-read about 58 times.

The bigger dial sat outside the code. Whole-run tokens scaled about linearly with coverage, roughly 300k per person researched.

How many people to research is a product decision. I price it per person for the stakeholder instead of promising that a code trim will halve the bill.

Check your setup read-only

Take the transcripts of the largest of your last 10 multi-agent runs by tokens. List each agent's turn count. List each agent's context size at the first and last turn. List each agent's output tokens against its cache-read tokens. Cache reads making up most of the total is expected. Look for context that grows to 3 times its first-turn size or more, since turns drive cost rather than payloads.

Passes ifNo agent's context at its last turn is 3 times its first-turn size or more. Turns times average context explains most of the total.

Access needed:agent-transcripts

If it fails: changes to make later (not part of the check)
  1. 01Split a run's usage into output, cache writes and cache reads before reacting to the total.
  2. 02Rank agents by turns times average context per turn, not by payload size or agent count.
  3. 03Batch independent tool calls into one turn. Cap how much context each agent accumulates.
  4. 04Price coverage per unit, such as per account or per person. Give that price to whoever decides scope.
Applies ifYour transcripts show agent runs of 20 or more turns, or runs that spawn several sub-agents.
TechniquecurrentRunning agents

How to decide whether an agent constraint is a prompt rule or a code check

Three buckets for every constraint in an agent prompt.

SymptomYour outbound prompt carries a long must-not list, and per-batch rules such as caps or no-repeat openers still fail.

The outbound email pipeline I built kept accumulating slot rules, phrase bans and per-batch caps. Stacked in the prompt, the cross-item ones failed first in drafts, because no single generation call sees the whole batch.

Every constraint now goes in one of three buckets.

  • Procedural micro-rule: one principle in the prompt, plus a deterministic check after the stage.
  • Honesty, brand or human-commitment rail: stays hard; its literally checkable part becomes lint.
  • Schema, enum or curated menu: stays, and gets stronger.

I write non-negotiables as failing tests rather than sentences. My signal-based selling package is no-send, and a test fails on any send surface in its source. A prose rule degrades quietly, and a failing test can't.

The Claude Code hooks guide describes hooks as shell commands run at fixed points in the lifecycle that give deterministic control, so actions happen without relying on the model to choose them.

I prove a new gate by replay instead of fixtures. Replay on a batch a reviewer already graded caught a softened ask for feedback, a variant of a banned opener that my synthetic fixtures missed.

Incident history stays out of the prompt. When I split a 99K agent prompt into operative rules and a maintainer-only ledger, pure narrative was only about 5.6K. Most explanation that reads like story is mechanism.

The sorting still takes judgment. Telling a rule that compensates for a model weakness from one born of a market defect takes an A/B test at each model change. Overused phrases stay banned whatever the model.

Check your setup read-only

Take the prompt file of each agent that generates text in batches. List the constraints in the file. Mark each constraint as procedure, rail or schema. Look in the code that runs after the prompt's stage for a check on each procedural constraint. Any cross-item rule with no code check is a gap.

Passes ifEvery cross-item procedural constraint in the prompt has a matching code check after the stage.

Access needed:local-config

If it fails: changes to make later (not part of the check)
  1. 01Sort every prompt constraint into procedure, rail or schema.
  2. 02Move each procedural rule into a check that runs after the stage. Leave one principle in the prompt.
  3. 03Write each non-negotiable as a test that fails, such as no send surface in a no-send package.
  4. 04Validate a new gate by replay. The gate must fire on every finding in a reviewer-graded defect batch. The gate must stay silent on a clean sibling batch.
  5. 05Keep operative rules inline. Move incident history to a file the agent never loads.
Applies ifA job in your setup has an agent generate more than one buyer-facing message or CRM value per run.
FindingcurrentGTM data

"Left the company" has many writers and many meanings

Departure sits in status picklists and checkboxes that other processes fill.

SymptomPeople marked as departed are still at their company, or people who left still show as current, depending on which field the sync reads.

The standard move is to read one "departed" field and drop the person from the account. In real CRMs, departure has no single home.

Departure often sits in one value of a status picklist that mostly holds qualification buckets. Such picklists often mix departure with qualification values.

Or it sits in a checkbox that more than one process can tick. An enrichment write-back can tick it from a single email-validator result, which is about an address rather than a person.

So read departure through curated rules that map the field and value pairs for each CRM. Give the employment edge an end date and a reason, and reopen it when the signal behind it is withdrawn.

Check your setup read-only

List every contact field that can mark a person as departed, from the CRM's field metadata. Count the values in each picklist that describe departure and the values that describe qualification. List the automations and integrations that fill each checkbox. A departure that rests on 1 enrichment or email-validation result alone is a gap.

Passes ifEvery process that fills a field marking a contact departed needs more than 1 enrichment or email-validation result.

Access needed:crm-readlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Map the exact field and value pairs that mean departure in each CRM. Ignore the rest of the picklist.
  2. 02Record an end date and a reason on the employment link instead of dropping the person.
  3. 03Keep the field and value that ended the link with the reason. A reader can then see what said the person left.
  4. 04Reopen the link when the field or value that ended it is withdrawn.
Applies ifA job marks contacts departed, or reads a CRM status field, checkbox or enrichment flag to end a person's tie to an account.
FailurecurrentRunning agents

Agents re-read their own wrong output as ground truth

A wrong inference recorded on a persistent page becomes the starting fact for every later run.

SymptomAn agent-maintained page still states a claim about a person that a human corrected in the thread.

A prototype deal agent I built kept a persistent page per account, including a stakeholder map that later runs read as ground truth. When someone on the deal team posted an ambiguous three-word note about a buyer's new title, along with a link, the agent wrote that the buyer had left the company and cited the link even though it said otherwise.

Four defects lined up, and each one is common:

  • The agent recorded its inference as fact.
  • "Appears to have left" in the table hardened by the time it reached the headline.
  • The run's own detector found the right record, but no stage could amend the page.
  • The weekly re-read took only agent posts as input and left out the human's correction.

Correctors that only reply in the conversation never heal the artifact.

The fix is four rules, plus one for deduplication, enforced by a check before the page is written rather than by instructions alone, because a finding that contradicts today's summary is the opposite of a duplicate.

Check your setup read-only

List the docs, plans or tables that 2 or more agent sessions wrote. Take the 5 most recently written claims in each one. Search the session transcripts after each claim for a human correction of the claim. Any corrected claim the doc still states in its old form is a gap.

Passes ifEvery sampled claim that a person corrected in a later session reads as corrected in the persistent doc.

Access needed:local-configagent-transcripts

If it fails: changes to make later (not part of the check)
  1. 01State that someone joined, left or changed role only from a primary source read in the same run.
  2. 02Make confidence monotonic so a headline inherits the weakest hedge among the claims beneath it.
  3. 03Rank a human correction above the agent's own earlier output. When a correction conflicts with the CRM, flag the conflict for a person. Do not overwrite the correction or the CRM value.
  4. 04Leave a "stale, supersede at next write" marker for the next authorized writer where write ownership blocks an edit.
  5. 05Exempt corrections from dedup. Label them as corrections to today's summary.
Applies ifYour transcripts show agent runs reading a page, plan or table that an earlier agent run wrote.
TechniquecurrentRunning agents

Use the top model to plan and review, and cheaper models to write

My top model writes specs and reviews, while cheaper models do the typing.

SymptomA top-model session hits its context or usage limit after a few prompts spent reading raw tool output.

The most capable model is the one I run out of first. In an interactive session it also carries the most fixed overhead, because it re-reads the instructions, tool schemas and the whole conversation every turn.

So my top-tier session only plans, writes specs, dispatches, reviews and integrates. The bulk runs in disposable contexts on cheaper models:

  • A pinned-Opus builder drafts against a written spec.
  • A research agent does the sourcing.
  • A Haiku checker runs pass/fail checks with read-only tools.

The spec keeps the cheaper model safe. It carries locked decisions, the files to read, the deliverables and a return contract. The builder flags any deviation instead of redesigning.

A vague spec moves the design work onto the cheaper model.

As the Claude Code subagent documentation lays out, sub-agents inherit the session's model unless the call, the agent's own definition or the CLAUDE_CODE_SUBAGENT_MODEL variable sets one. With none of them set, the saving disappears with no error.

On an early build of a scoring rubric done this way, the draft needed two small integration fixes, and more than 200k tokens of drafting, research and testing stayed off the top model.

Check your setup read-only

Take the 3 longest of your last 10 top-model sessions by turn count. Count the tool calls that returned raw data in each transcript. Count the calls that returned a sub-agent's conclusion. If raw-data calls outnumber conclusions, the top model is doing the work instead of planning it.

Passes ifIn each sampled session's transcript, calls that returned conclusions equal or outnumber calls that returned raw data.

Access needed:agent-transcripts

If it fails: changes to make later (not part of the check)
  1. 01Keep the top model on intent, specs, review and integration.
  2. 02Write the spec before dispatching, including locked decisions, files to read, deliverables and a return contract.
  3. 03Set a default sub-agent model in config with the CLAUDE_CODE_SUBAGENT_MODEL variable. Pass a model explicitly where it differs from the default. Do not let a sub-agent inherit the top model.
  4. 04Send an investigation to a sub-agent when the raw output would cost more than the sub-agent's start-up cost. Have the sub-agent return conclusions, not raw output.
  5. 05Keep work of 2 tool calls or fewer, single-file edits and judgment-dense integration in the main session.
Applies ifYour top-model session transcripts list a tool that spawns sub-agents, and some sessions reach their context or usage limit.
TechniquecurrentRunning agents

Cap sub-agent spawns with a hook, and let the cap fail open

A hook caps spawns per session, and allows them if it breaks.

SymptomA session's transcript shows sub-agents spawning sub-agents, and the token budget empties mid-session.

Sub-agents with the full tool set can spawn sub-agents of their own, and a runaway swarm drains the token budget I share with everything else. Telling an agent in prose not to spawn will not hold a limit.

So a pre-tool hook counts every agent spawn in a session and denies spawns past a fixed cap. It fires no matter which agent makes the call.

It also fails open, so any error in the hook allows the spawn. A cost guardrail should never block legitimate work. Guards on sends, CRM writes and deletes fail closed.

The agents carry their own limits too. The builder and the checker have no spawn tool. The research agent is told not to spawn, and the session cap bounds it.

Large fan-outs I intend go through a workflow runner with its own concurrency and total caps.

Watchers get a funnel instead of a swarm. Each stage costs more than the last and sees only what the earlier stage couldn't settle:

  • Code prefilters by term overlap.
  • A Haiku pass labels what's left.
  • One Sonnet triage ranks by match strength.
  • Opus audits only on a match, scoped to the affected files.

A count can't tell an intended fan-out from a runaway one, so put a person at the cap to decide whether to raise it.

Check your setup read-only

Take the largest of your last 10 sessions by tokens. Count the sub-agent spawns in its transcript. Count only the tool-call records whose tool name is your spawn tool. Do not count the tool's listing or definition, which transcripts also carry. Count how many spawns came from sub-agents rather than the main session. Look in your hook config for a per-session spawn cap. Any spawn from a sub-agent with no cap behind it is a gap.

Passes ifNo sub-agent spawned another, or a per-session spawn cap in the hook config covers every spawn in the session.

Access needed:agent-transcriptslocal-config

If it fails: changes to make later (not part of the check)
  1. 01Count agent spawns per session in a pre-tool hook. Deny spawns past a fixed cap.
  2. 02Make a cost cap fail open: any error in the hook allows the spawn. Make guards on sends, writes and deletes fail closed.
  3. 03Note that hook errors and timeouts allow the call by default, per the Claude Code hooks reference. Configure fail-closed guards to block on failure.
  4. 04Give builder and checker agents no spawn tool.
  5. 05Route large intended fan-outs through a runner with its own concurrency and total caps.
  6. 06Put a code prefilter and a small-model labeler ahead of any large-model call in a watcher.
Applies ifAn agent's tool list or config in your setup includes a tool that spawns other agents.
FindingcurrentGTM data

A soft delete may not move your copy's modified time

Freshness gates keyed on your copy's modified time skip soft deletes.

SymptomRecords deleted in the CRM keep appearing in answers, while in your warehouse copy only the connector's sync column shows they were touched.

Incremental pipelines pick what to reprocess by the CRM's last-modified time. It's the standard freshness gate, and the right clock for ordinary edits.

A soft delete is the exception. In the CRM, a delete may restamp the record itself. But a connector learns about deletes through a separate deleted-records call, so the copy of the modified time in your warehouse never moves; only the connector's sync column does. Fivetran's Salesforce documentation says it captures soft-deleted records through the sObject Get Deleted endpoint.

A gate keyed on that copied stamp then sees nothing new. The delete is skipped, and the record keeps feeding answers as if it were live.

A job that reads the CRM directly with a standard query never sees deleted rows at all; only a query that includes deleted rows returns them.

The answer is two clocks with two jobs.

  • The sync stamp decides what gets processed.
  • The CRM stamp stays the displayed time, because it says when the business record changed.

In a synthetic test set with 50 soft-deleted records in a warehouse copy, a reprocess gate on the copied CRM modified time left all 50 still served; a gate on the sync stamp left none. The set shows the mechanism, not how common it is.

Check your setup read-only

List records in the CRM's recycle bin from the last 30 days. Compare each record's modified time in your warehouse copy with the connector's sync time. Check whether only the sync time moved. Check whether your pipeline gates on the copied modified time. If both are true, those records never reached you as gone.

Passes ifEvery record in the last 30 days of the recycle bin reached your pipeline as gone. Otherwise, your freshness gate keys on the sync time.

Access needed:crm-readlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Gate reprocessing on the connector's sync stamp, not the CRM's last-modified time.
  2. 02Keep the CRM's last-modified time as the "changed at" time you show people and agents.
  3. 03Read the deleted flag on every record the sync stamp surfaces. Retire the record downstream when the flag is true.
  4. 04Use the query mode that includes deleted records when reading the CRM directly for deletes.
  5. 05Apply the same two-clock gate at every layer that keeps its own copy, not only the first load.
Applies ifA job config in your setup reads the CRM incrementally by last-modified time, such as an incremental cleanup or an enrichment pass.
FindingcurrentRunning agents

'What's happening now' needs a date filter instead of a relevance store

Recency decay re-weights old facts but never excludes them.

SymptomAn agent's account brief describes a project or deal stage that ended weeks ago as current.

A brief that reads current state from a relevance-ranked store with recency decay can narrate weeks-old project names as current.

The store looked recency-aware, which made the mistake easy.

Decay only re-weights, so an old fact keeps part of its score. A salient old fact beats a fresh, ordinary one, and the agent narrates page one as the present.

Current-state questions now go through a date-bounded query scoped to the entity, the only path that excludes by date. Relevance ranking stays for durable context, such as the standing thesis and long-running risks.

Rolling verification has the same blind spot between checks. If you re-verify people on a rolling window, a job change the week after a check stays invisible until the next one.

Any first-party sign of a move acts as a cheap trigger and bumps that person to the front of the next verification pass.

A date-bounded query suits thematic questions. For an exhaustive list of every interaction in a window, I page the full record instead.

Check your setup read-only

Take the 3 most recent agent transcripts that answer a current-state question about an account. Look up the source date of every fact each answer cites, in the store the agent queried. Any cited fact older than the window the question asked about, shown without its date, is a gap.

Passes ifEvery fact cited in the 3 answers falls inside the asked window or carries its date in the answer text.

Access needed:agent-transcriptscontext-read

If it fails: changes to make later (not part of the check)
  1. 01Answer "what's happening now" questions with a date-bounded query, not the relevance-ranked inventory.
  2. 02Use relevance ranking only for durable context, and show every surfaced fact with its date.
  3. 03Read structured state, such as renewal date or opportunity stage, from the record, never from prose facts.
  4. 04Treat any cheap sign of a job change as a proposal only, never as truth.
  5. 05Move a proposed person to the front of the next verification pass. A human confirms the proposal before it becomes truth.
Applies ifYour agent's tool config points at a relevance-ranked search store, and transcripts show it answering current-state account questions.
FindingcurrentGTM data

Two forecast-category fields: one set from stage, one reps keep

Coalescing them mixes two vocabularies, and only on closed deals.

SymptomForecast-category breakdowns show values from two different picklists, and the mix concentrates on closed opportunities.

Salesforce opportunities carry a standard forecast category, and many teams add a custom one that reps maintain. The usual read takes the custom value when present and the standard value otherwise.

The two fields speak different vocabularies. The standard one follows the stage mapping, while the custom one follows the team's forecast call. Salesforce's Opportunity object reference says ForecastCategoryName is implied by StageName and updates automatically from the stage-category mapping when the stage changes, though it can be overridden.

Reps stop maintaining the custom field after close. So the coalesced value switches vocabulary exactly on closed deals. It takes the custom value where a rep left one and the standard value where they didn't.

The affected share can be small, but all of it is closed deals, the ones forecast accuracy is judged on.

In a synthetic test set of 300 opportunities, coalescing the two fields switched 58 of 144 closed deals to the stage-based vocabulary and none of the 156 open ones. The set shows the mechanism, not how common it is.

Check your setup read-only

Compare the standard forecast category with the custom one on closed opportunities where both hold a value. If any closed deal reports a value from the other field's list, a custom-else-standard rule is mixing vocabularies.

Passes ifEvery closed opportunity your reports or agents read takes its forecast category from one field's vocabulary only.

Access needed:crm-readlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Store the standard and the custom forecast category as 2 named fields. Never coalesce the 2 fields.
  2. 02Tell the agent which field answers which question: the reps' call for the open forecast, the stage-based value for history.
  3. 03Count closed deals where the 2 fields disagree before any forecast-category report.
Applies ifYour digests, routing or agents read forecast category, and your CRM has a custom forecast-category field alongside the standard one.
FindingcurrentGTM data

Same name, same account, no shared id: one person or two?

No deterministic rule settles these pairs, so judge them and keep merges reversible.

Symptom2 contact records have the same name at 1 account and no shared email or id. Agents either count the person twice or blend 2 people.

Dedup usually rests on a shared identifier, such as an email, a phone or a CRM id. Two records with the same name at the same account and none of those leave the rule with nothing to go on.

No deterministic rule exists for this case. Joining on name and account blends two colleagues who share a name, and refusing leaves real duplicates in place.

So have a model judge each candidate pair. Give it both records' neighbourhoods, the meetings, messages and people around each one, rather than the two records alone.

Have the model return a confidence instead of a yes. Above a high confidence bar the pair merges automatically, and below it the pair goes to a person. Remember a "keep separate" verdict, and keep every merge undoable.

Check your setup read-only

List pairs of contacts at the same account with matching names and no shared email, phone or external id. Count the pairs. Look for a recorded reason on the 20 most recent pairs your dedup joined. More than 1 of 20 joined with no record of why is a gap.

Passes if19 or more of 20 sampled same-name pairs your dedup joined carry a recorded reason. Each join can be undone.

Access needed:crm-readlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Collect candidate pairs by same name and same account with no shared identifier.
  2. 02Judge each pair from the activity and people around both records, not from the two records alone.
  3. 03Merge automatically above a high confidence bar. Route lower scores to a person.
  4. 04Store "keep separate" verdicts so the same pair isn't judged again.
  5. 05Keep every merge reversible.
Applies ifYour dedupe or enrichment matches people across CRM, calendar and email sources by name and domain, where many records lack an email or id.
FindingcurrentGTM data

People who leave a company lose the link to their past work

Employment is a time window, so facts link by when they happened.

SymptomFacts from a former employee's calls and emails link to no one, or attach to the wrong account, once their CRM user is deactivated.

The standard model links a person to their employer with one "currently employed" edge. When the CRM deactivates the user, that edge goes away, and so does the path from their past work back to them.

Deactivated users can be a large share of CRM users, making departed users a normal part of the data. Facts from before someone left are still true and still theirs, yet with only a current edge those facts lose their owner and can get attached across accounts. Modeling employment as a window keeps those facts tied to their owner. The start of the window needs care too, because a CRM user's created date is different from their hire date, so the window should start from the person's first recorded activity.

In a synthetic test set of 2,000 dated facts, linking each to the person's current employer put 286 on the wrong account; linking each to the employment window that covers its date, opened at first activity, linked all 2,000 correctly. The set shows the mechanism, not how common it is.

Check your setup read-only

Count deactivated users against all users on the CRM user object. Take the 5 most recently deactivated users. List 4 facts dated before each user's deactivation. Look at whether each fact still links to that person. More than 1 of 20 from before the departure that no longer links to them is a gap.

Passes if19 or more of 20 sampled facts dated before a former user's deactivation still link to that person.

Access needed:crm-readcontext-read

If it fails: changes to make later (not part of the check)
  1. 01Store employment as an edge with a start and an end. Keep the edge when the person leaves.
  2. 02Link each fact to the employment window that covers the fact's event time, not to whoever is employed today.
  3. 03Start the window from the person's first recorded activity, never from the CRM user's created date.
  4. 04Treat a user deactivation as the end of a window, not as the removal of the person.
Applies ifYour CRM user object holds deactivated users, and their earlier calls and emails sit in your fact store.
TechniquecurrentRunning agents

Review an agent job's token cost before its first run

Waste found after a job runs is found too late.

SymptomA usage-limit refusal stops a job, and nobody can say which earlier job spent the budget.

My scheduled routines and skills share one token budget with the work I do by day. When a usage budget runs short, asking jobs what they spent after they ran finds the waste too late.

A token budget is shared capacity. A token spent on waste is a job that doesn't run.

Once a job has burned the budget, finding the waste is a postmortem.

So anything that calls a model repeatedly gets a token-waste review before it counts as done. Three pieces hold it together:

  • A review skill is the lint.
  • One line in my project instructions makes it a gate.
  • The end-of-session review adds each new pattern it sees.

The checklist started with 15 patterns and now holds 191, each with the case that produced it and a fix. The review reports only the items that trip, plus a count of the rest.

One typical entry is a 7 KB config body re-emitted through model output on four one-field updates for about 28 KB of output. Keeping that data on disk and scripting each update from the file keeps it out of the model.

Check your setup read-only

Read the job registry and the skills folder. List the skills and scheduled jobs that call a model more than once per run. Look for a dated cost review of each one before its first run. Any such job without a review is a gap.

Passes ifEvery skill or scheduled job that calls a model more than once per run has a cost review. Each review is dated before the job's first run.

Access needed:schedulerlocal-config

If it fails: changes to make later (not part of the check)
  1. 01Review each skill, scheduled routine, dispatch template or model-calling script against a token-waste checklist before it counts as done.
  2. 02Report only the checklist items that trip, each with a concrete fix. Give the rest as one count.
  3. 03Keep stable reference data in a file and script edits from it instead of re-emitting it through the model.
  4. 04Add each new waste pattern to the checklist, with its case and fix. Make the addition at the end of the session that found the pattern.
Applies ifYour skills folder or scheduler holds a skill or job that calls a model more than once per run.

That's every post so far.

Building something similar? Compare notes with me on LinkedIn.