CASE STUDY

Financial Services and Wealth Advisory.

A First Strategy case study.

Company name is held in confidence.

PDF Download the full case study (PDF).

Financial services and wealth advisory

The season that did not fit in the person

A private wealth advisor owed every one of his 280 clients a bespoke package twice a year: portfolio review, market outlook, plan update, built on research and delivered as a presentation and a report. Each one took one to three hours to produce by hand, inside a six-week window he compared to tax season. The hours that built the documents came out of the time the documents existed to defend: time with the clients themselves.

What was at stake

The deliverables are the twice-yearly proof, in writing, of why each family keeps their money with this advisor. A document that reads as generic does not save time, it costs the relationship. At the same time, the math was already breaking. Each season carried 280 to 840 hours of production, on top of the day job, inside a window that holds maybe 300 hours of one person's effort. The roster could not grow, because every new client meant another one to three hours added to a season already over capacity. The season was capping the practice.

Diagnosis

The advisor had already tried the industry's standard fix. Hire support staff, train them, hand them the production. It failed twice over. It failed on quality because the thing each deliverable is made of is not in any system. The CRM holds contacts and meeting notes. The portfolio platform holds positions and performance. Neither holds the read: what this client worries about, what was promised at the last review, why this family's risk posture changed last spring. That lived in the advisor's head and nowhere else. Training transfers process. It cannot transfer years of sitting across the table.

It also failed on scale. Every document a hire produced still had to pass through the advisor for the client-specific read and the final check. The bottleneck did not move. It gained a queue, and the advisor was now paying people to produce work he then spent his nights double- and triple-checking.

The root cause was a single sentence: the knowledge each deliverable depends on lives in one place, the advisor's head, so everything built from it must be built at one person's speed inside a window that does not move. Any fix that adds hands without holding the knowledge fails the way the hires failed, no matter how good the output looks on the page.

The strategic shift

We arrived carrying the obvious theory. With 280 clients, surely most deliverables are mostly alike. Build one strong template, pour each client's data in, season solved. The advisor killed it almost immediately, and he was right. We sat with the real documents and the theory fell apart against them. Each deliverable was shaped by the client it served: the holdings, the plan, the family situation, the conversation history. The bespoke quality was not polish on top of the analysis. It was the analysis. A client who has worked with the same advisor for years can tell when a document was written for them and when it was written for everyone, and the moment one of them senses a form letter, the deliverable stops proving the relationship and starts undermining it.

So the build became a memory before it became a generator. Instead of a template engine, a living memory system that understands the clients, connected to the CRM and the portfolio platform, holding the read that had only ever lived in the advisor's head. Production draws on that memory to draft each package in the firm's voice, and points the advisor at exactly what needs human verification rather than leaving him to recheck everything. The trade-off was conscious. The human review never goes away. This is wealth advisory, where a wrong number in a client document is not a typo but a trust event, so the design is collaborative on purpose, permanently.

Implementation

The engagement started on an existing relationship. A few conversations over two weeks, a handshake, and a monthly retainer that had to re-earn itself every month. Then the direct ask: get the season off my desk without lowering the bar my clients expect.

The first proof had to come fast and on real work. Two weeks in, the system produced its first client deliverable, in the firm's voice, and the advisor judged it 90 percent to perfect. That number converted the engagement. Not because 90 percent is good enough to ship, it is not and never was, but because the missing ten percent was now a list of specific corrections instead of a leap of faith. Every correction fed the memory. The drafts opened better each pass.

From there the build ran incrementally, one deliverable type at a time, with the advisor reviewing every draft. The verification flags went in early. The system pointed at the figures, the client-specific reads, and the recommendations, so the advisor's attention went where it mattered and the rest got a final read for voice and fit. The skills were built on a third-party subscription stack, so there was nothing for the practice to host, operate, or maintain. Advisors advise. Nobody becomes a systems administrator.

The system has now carried two full client cycles. The second season's drafts opened better than the first season's ended, because the corrections compound in the memory. The same season exists, in some version, at every desk in the group, so the capability is now rolling out advisor by advisor, each with their own client memory, their own voice calibration, and their own permanent review. Twelve advisors are live; the full practice is planned across the next twelve months. The pacing is deliberate, because an advisor who distrusts the first draft is lost for good.

Results

The season now fits inside the six-week window. A deliverable that took one to three hours to produce by hand now takes 15 to 45 minutes to review and finish. The same 75 percent reduction holds at both ends of the range. The season's load fell from 280 to 840 hours to 70 to 210, and the paid double- and triple-checking is gone because the checking is finally aimed.

The operating change is the deeper result. The knowledge that used to live in one head and break the calendar twice a year now lives in a memory system the practice can carry forward. The advisor got back what he wanted when he first described the season: his time. More of it with his family, more of it with clients, and enough of it to work on landing new ones, which the old season had made almost unthinkable. The roster is no longer capped by the production window.

Quality moved in the same direction by the advisors' own account. We report it the way we received it: the advisors say the deliverables are better. We have not measured that independently, and we will not pretend we have. The hours, we measured.

What proves it

Two full client cycles have run on the system. The second cycle showed the first was not a fluke and the corrections were compounding. The capability is now rolling out across the group: 12 advisors live, the rest sequenced across the next 12 months, each earning trust the way the first build did, one real deliverable at a time. The engagement has quietly changed shape from building, to tuning, to the occasional improvement call. The skills First Strategy tunes today are headed for the practice's own operations team, which is the last step of leaving on purpose.

For an operator carrying a season like this: more hands will not move the bottleneck if the knowledge is not in the room with them. The fix is to write the knowledge down where a system can read it, keep the review where the accountability is, and let the corrections compound. The season stops fighting the calendar when it stops running at one person's speed.

Day One Proposal

The entry agreement

Agreed with a wealth advisor, on an existing relationship.

What this is

Our standard entry is a fixed-fee day inside the business and a playbook within two weeks. This engagement did not need it. The relationship was already in place, the problem was already named, and the trust a Day One exists to earn was already earned. We talked through the scope over two weeks, shook hands, and started work.

What follows is the scope as we agreed it.

The problem as you named it

Twice a year, every one of your 280 clients is owed a substantive deliverable: a portfolio review, a market outlook, a plan update, built on research and delivered as a presentation and a report. Each one takes one to three hours to produce by hand, and each one has to be yours: your read of the client, your firm's voice, no template showing through. The season runs about six weeks. You described it the way accountants describe tax season.

You tried hiring and training staff to produce them. It did not scale, and the output did not meet the bar your clients expect. The fix is not more hands.

What we will do

Build the production system, incrementally, inside your real work. Not a platform to evaluate, not a pilot in a sandbox. We start with your actual deliverables, your actual clients, your actual season.

  • We work from what already exists: your CRM, your portfolio data, your past deliverables in the firm's voice.
  • The first proof comes fast: a real client deliverable, produced by the system, for your review.
  • You review everything. Nothing reaches a client without your sign-off. That is permanent, not a pilot condition.
  • The system improves through your corrections. Every review makes the next deliverable better.

What you walk away with

A system that produces your seasonal deliverables with your judgment kept in. Built piece by piece, so each month's work stands on its own. If the work stops earning the retainer, stop the retainer.

The terms

A monthly retainer of [monthly retainer]. No build fee, no long commitment. The retainer continues only as long as the work earns it.

What we need from you

  • Access to the systems the work runs on: the CRM and the portfolio platform.
  • Past deliverables that show the firm's voice and the bar to hit.
  • Your review time, and your honesty about what is wrong with each draft. The corrections are how the system learns your clients.

What happens next

We start building. The first deliverable you can judge arrives within weeks, not quarters. From there, the system earns its place one deliverable type at a time, and the retainer is the only commitment on the table.

Day One Audit

The one-line finding

The advisor's problem is not effort and it is not volume. It is that the knowledge each deliverable depends on lives in one place, the advisor's head, and everything built from it must therefore be built at one person's speed inside a window that does not move. Twice a year, 280 clients are owed a bespoke deliverable, each taking one to three hours by hand. That is 280 to 840 hours of production inside a six-week season. A single person working the season hard has perhaps [240 to 360 hours] to give it. The arithmetic does not close, and every attempted fix that adds hands fails on the same constraint: the hands do not hold the knowledge.

How we looked

No factory floor to walk, so we walked the work itself. Working sessions with the advisor across the entry weeks: real deliverables from past seasons opened and read, the production of one deliverable traced step by step, the systems behind it opened and compared against what the advisor actually did. The figures below that are cleared engagement record are stated plainly; where a figure is arithmetic derived from them, or an observation rather than a count, this audit says so.

The deliverable, and why it resists shortcuts

Twice a year, every client receives a substantive package: a portfolio review, a market outlook, a plan update, built on research, delivered as a presentation and a report. The natural assumption, and the one we carried in, is that 280 of these are mostly the same document with different numbers. Build one strong template, pour each client's data in, season solved.

The assumption is wrong, and the advisor knew it was wrong before we did. Each deliverable is shaped by the client it serves: their holdings, their plan, their risk posture, what is happening in their life, what was discussed at the last review. A client who has sat across the table from this advisor for years can tell when a document was written for them and when it was written for everyone. The bespoke quality is not polish. It is the product. Any fix that flattens it fails the same way a form letter fails.

The systems landscape

The tools are ordinary for the industry. What matters is the gap between their official role and their actual one.

System Official role Actual role
CRM The client record Contacts, meetings, and notes. Holds facts about clients, not the read of them
Portfolio platform Holdings and performance of record Exactly that, and only that. Clean data, no narrative
Research sources Market and product research Raw material, the same inputs every advisor in the industry has
Presentation and report tooling Production Hand assembly, one document at a time
The advisor's memory Not on any diagram The real system of record. What each client worries about, what was promised last review, which nuance matters this season

The last row is the audit's finding. Four systems hold data. None holds the knowledge the deliverable is actually made of. That knowledge has a single point of failure and a fixed production speed, and both belong to the advisor.

Stakeholder map

Role What they own Where their pain is Their definition of the problem
The advisor The client relationships and every word that reaches a client Six weeks of production, twice a year, on top of the day job The season costs me the time my clients are paying for
The clients Their plans and their trust None visible, and keeping it that way is the constraint They never see the season. The deliverable must arrive as if it were the only one
Seasonal support staff Production assistance Trained on process, not on twenty years of client nuance We can build the document but not the read of the client
Practice leadership The advisor model at scale Every advisor in the group carries some version of this season If this is fixable for one advisor, it is fixable for the practice

The work, end to end

One deliverable, traced from start to client. Times are the advisor's, within the cleared one-to-three-hour total; the per-step split is our observation from the traced work.

  1. Pull the client's holdings and performance from the portfolio platform.
  2. Reread the client: CRM record, meeting notes, prior deliverables, the advisor's own recall of the last conversations.
  3. Research the season's market picture as it applies to this client's allocation and plan.
  4. Draft the analysis: what changed, what it means for this client, what to recommend.
  5. Build the presentation and the report, in the firm's voice.
  6. Check everything. Then check it again. A wrong number in a client-facing financial document is not a typo, it is a trust event.

Steps 1 through 3 are assembly: gathering what is already known before judgment can be applied. Steps 5 and 6 are production and verification. The advisor's actual value, the judgment in step 4, occupies a minority of the clock. Most of each hour goes to assembling context the advisor already possesses and to guarding against the errors that long hours produce.

Friction quantified

The cleared record: 280 clients, one to three hours per deliverable, a season of about six weeks, twice a year. The rest is arithmetic.

Measure Value Basis
Production load per season 280 to 840 hours 280 deliverables at 1 to 3 hours, cleared figures
One person's season capacity [240 to 360 hours] Six weeks at 40 to 60 hours per week, before a single client meeting
The gap The season does not fit in the person Derived. The midpoint load of roughly 560 hours is about [90 hours a week]
Annual production load 560 to 1,680 hours Two seasons
Error pressure Rises with hours Human production over long hours in a compressed window produces errors. Cleared record, stated by the advisor

The checking deserves its own line. Because errors rise exactly when capacity is most strained, the late season demands the most verification at the moment there is least time to do it. The advisor was paying for help to double- and triple-check work, which is paying twice for the same hour.

Why hiring failed

The advisor's one prior fix was the industry's standard one: hire and train support staff to produce the deliverables. It failed on both axes that matter, and the failure is structural, not a hiring miss.

  • It failed on quality because the production knowledge is not written anywhere. Training transfers process: where the data lives, how the document is formatted. It cannot transfer the read of 280 clients accumulated over years of conversations. The hires produced documents that were correct and generic, which is exactly what the deliverable must not be.
  • It failed on scale because every document a hire produced still had to pass through the advisor for the client-specific read and the final check. The bottleneck did not move. It gained a queue.

This is the diagnostic that matters for what comes next: any fix that cannot hold the client knowledge fails the way the hires failed, no matter how good its output looks.

Root cause

Three facts compound:

  1. The knowledge each deliverable is made of lives in one head and nowhere else.
  2. The deliverables must be bespoke, so the knowledge is load-bearing in every one of the 280.
  3. The window is fixed and the roster does not shrink.

Fix any one and the season eases. Fix the first and the other two stop mattering: if the client knowledge can live in a system, production stops running at one person's speed, and bespoke stops being the expensive option.

Where AI fits, and where it does not

  • Fits: the memory. A system that holds what the advisor knows about each client, connected to the CRM and the portfolio data, so that assembling context stops consuming the majority of every deliverable hour.
  • Fits: the production. Drafting the analysis, the presentation, and the report in the firm's voice, from that memory, for the advisor to review and correct.
  • Fits: the verification. Pointing the advisor at exactly what needs human eyes in each draft, instead of the advisor rechecking everything under deadline.
  • Does not fit: the advice. What to recommend to a client is the advisor's call. The system assembles and drafts; it does not decide.
  • Does not fit: the relationship. The client is paying for the advisor. Nothing about that changes.

Opportunity, sized

If production per deliverable falls from one to three hours to a fraction of that, with the advisor reviewing rather than producing, the season changes category: from physically impossible for one person to manageable inside a normal working week.

The sizing was later checked against the result, which is the point of stating it. Production per deliverable fell to 15 to 45 minutes, a 75 percent reduction at both ends of the range. The season's load fell from 280 to 840 hours to 70 to 210 hours. The recovered time is 210 to 630 hours per season, twice a year, and it returns to the highest-value use in the practice: clients, and the capacity to land new ones.

Risks and constraints we observed

  • The quality bar is non-negotiable. A client must never receive a document that reads as generated. The bespoke read is the product.
  • A human stays accountable for every number and every word a client sees. This is wealth advisory; trust is the entire business.
  • The advisor's confidence must be earned incrementally. One bad draft early would confirm the suspicion that this is the hires all over again.
  • The fix must not create an operations burden. An advisor cannot also become a systems administrator.

The signal we leave with

The first move is the seasonal deliverable production for this one advisor: build the memory, produce the drafts, keep the advisor's review on everything, and measure against the one-to-three-hour baseline. If it holds for the hardest version of the problem, 280 bespoke deliverables in six weeks, it holds for the practice. The plan, sized by impact, is the Playbook and Delivery Proposal.

Playbook and Delivery Proposal

The playbook and the delivery proposal are one document because they are one act. The playbook says where AI fits in an advisory practice and sizes the moves in order. The delivery plan says how the first move gets built. The first earns the second, and in this engagement the second ran on a monthly retainer that had to re-earn itself every month.

Part One: The Playbook

A written read for operators. It answers three questions: where AI fits in this practice and where it does not, the highest-leverage moves in sequence, and what it takes to run them.

Where AI fits, and where it does not

It fits the seasonal deliverable production, where 280 bespoke client packages compress into a six-week window twice a year at one to three hours each. The constraint is not judgment, it is that the client knowledge lives in one head and production runs at that head's speed. The evidence is in the Day One Audit.

It does not fit the advice or the relationship. What gets recommended to a client, and the conversation that delivers it, stays with the advisor. The system assembles, drafts, and points at what needs checking. It does not decide and it does not meet clients.

How to read the roadmap

The first move we diagnosed inside the advisor's real work and can size against a measured baseline. The second is the first move's natural consequence, proven the moment the first holds. The rest we saw the shape of but did not diagnose, and we say so rather than dress them up.

Each move reads across six dimensions: time, accuracy and quality, cost and recovered revenue, growth, employee experience, and risk.

The roadmap at a glance

# Move Status Leverage Containment Why it sits here
1 Seasonal deliverable production, one advisor Diagnosed, sized Highest One advisor, one season The most acute pain, the hardest test, the cleanest baseline
2 The practice rollout Earned by move 1 High One advisor at a time The same season exists across the group. Proof at one advisor prices the rest
3 Client meeting preparation Candidate, not yet diagnosed Medium One workflow The same memory that builds the season can brief any meeting
4 Between-season client requests Candidate, not yet diagnosed Medium One workflow Ad-hoc questions draw on the same client read
5 Prospect and onboarding materials Candidate, not yet diagnosed Medium One workflow New-client capacity is where the recovered time goes

Move 1: Seasonal deliverable production (start here)

A living memory system that understands the clients, the CRM, and the portfolios, and produces the seasonal deliverables from that understanding. The advisor reviews every draft, and the system points at exactly what needs human verification rather than leaving the advisor to recheck everything. Collaborative, not autonomous, by design and permanently.

  • Time: the baseline is one to three hours per deliverable, 280 to 840 hours per season. The build took production to 15 to 45 minutes per deliverable, a 75 percent reduction at both ends of the range, putting the season at 70 to 210 hours. The recovered time is 210 to 630 hours per season, twice a year.
  • Accuracy and quality: the old error source was human production over long hours in a compressed window. The system removes the long hours and directs the advisor's checking to the places that need it. Quality improvement beyond that is what the advisors report rather than what we have measured, and this playbook says so plainly.
  • Cost and recovered revenue: the paid help that existed to produce and to double- and triple-check work is no longer needed for the season. The larger value is the advisor's own recovered hours, returned to the highest-value work in the practice.
  • Growth: the season stops capping the roster. 280 clients was the load that broke the old process; the new one does not break there, and the recovered time is capacity to land new clients.
  • Employee experience: the six weeks of hell end. The advisor described the wins directly: sanity, family, and time with clients instead of documents.
  • Risk: low, and contained by design. Every deliverable passes human review before a client sees it. The worst case at any point is the old process: the advisor produces by hand, as before. Nothing operational is ripped out.

Move 2: The practice rollout

Every advisor in the group carries a version of the same season. Once the system holds for one advisor at 280 clients, the question stops being whether and becomes the order. Roll out advisor by advisor, each with their own client memory, their own voice calibration, and their own review. The rollout is running now: 12 advisors live, the full practice over the next 12 months.

  • Time and cost: move 1's per-deliverable gain, multiplied across the group, without re-deriving the build.
  • Risk: each advisor is a contained deployment with the same human review. The pacing is deliberate; an advisor who distrusts the first draft is lost for good, so each rollout earns trust the way the first one did.

The later moves: named, not yet diagnosed

The memory the season build creates is the asset. Once it holds each client's situation, three candidates draw on it: briefing the advisor before any client meeting, answering between-season requests without re-assembling context, and producing prospect and onboarding materials with the same production quality. Each is a contained workflow with its own measurable baseline. None is committed, and none has been diagnosed to the hour. They earn their turn the way the first move did.

What it takes to run the moves

  • Earn trust with a real deliverable, fast. The first proof must be a real client document in the firm's voice, judged by the person who owns the bar.
  • Keep the human review permanent. This is wealth advisory. The review is not a pilot condition that falls away; it is the design.
  • Build the memory, not just the output. A document generator without the client read produces what the hires produced. The memory is what makes bespoke scale.
  • Improve through correction. Every review feeds the system. The deliverables get better season over season because the corrections accumulate.
  • Keep the operations burden near zero. Advisors advise. The system runs on a subscribed stack with custom skills on top, not on infrastructure the practice must operate.

Who runs it

The advisor runs the reviews and owns every client-facing word. First Strategy builds and tunes the skills, then hands them to the practice's operations team. The aim, stated at the start and meant literally, is to work ourselves out of the job.

Part Two: The Delivery Plan

How the first move was built on the retainer. Recorded in the standard proposal form.

What we understand

280 clients, twice a year, six weeks, one to three hours per deliverable, every one bespoke. Hiring failed on quality and scale because the client knowledge is not transferable by training. The fix has to hold the knowledge, not add hands.

What we will build

A living memory system that understands the clients, the CRM, and the portfolios, and produces each seasonal deliverable as a draft in the firm's voice, flagging exactly what needs the advisor's verification. Custom-built skills on a third-party subscription stack: nothing for the practice to host, operate, or maintain.

How we will work

Incrementally, on the monthly retainer, with each increment judged on a real deliverable. Mapped to the WISER canons:

Phase 1: Interrogate

Test the core bet cheaply: can a system produce one real client deliverable in the firm's voice, good enough that the advisor's corrections are refinements rather than rescues? Weeks, not quarters. This phase ended with a deliverable the advisor judged 90 percent to perfect, two weeks in. That result is what turned the retainer from a bet into a build.

Phase 2: Solve

Build the memory and the production for the full deliverable set, one deliverable type at a time. The advisor reviews every draft; every correction feeds the system. End of phase: a full season produced on the system, against the one-to-three-hour baseline.

Phase 3: Expand

Run the second season, then take the system to the practice: advisor by advisor, each with their own memory and voice, each earning their advisor's trust the way the first build did. End of phase: the rollout sequenced and running.

Phase 4: Refine

Narrow what needs verification as the evidence accumulates, hand the skills to the practice's operations team, and step back to occasional calls. End of phase: the practice owns the capability and we are no longer needed for the season to run.

What we need from you

  • Access to the CRM and the portfolio platform.
  • Past deliverables that carry the firm's voice.
  • The advisor's review on every draft, and blunt corrections. The corrections are the training.

Infrastructure

The practice subscribes to the third-party stack. We build and tune the custom skills on top of it. There is no system for the practice to run.

Investment

A monthly retainer of [monthly retainer]. No phase fees, no long commitment. Each month's work stands on its own, and the retainer continues only as long as it earns its place.

Charter

What a Charter is

Not a project plan. A Charter is the memory that survives the chaos. Its value is the decision log: when someone asks a year later why the system was built bespoke instead of templated, or why the practice never hired a systems administrator for it, the answer is here, with the alternatives that were weighed and the evidence that settled it.

Metadata

Field Value
Project Seasonal deliverable production: the living memory build
Client The wealth advisory firm (anonymized)
Charter Keeper First Strategy
Dates Redacted; relative markers used
Current canon Expand. The first advisor's system is governed and in Refine; the practice rollout is at 12 advisors
Version Current state, rollout in progress

Positions

A small engagement holds the same tensions with fewer people. One person holds several Positions.

Position Who held it Tension owned
Sponsor The advisor Authority. Owned the objective, judged every deliverable
Guide and Architect First Strategy Translation, curiosity, stewardship. Carried the method, kept this Charter
Builder First Strategy Execution. Built incrementally, discarded what failed
Sage and Scout The advisor Context and empathy. The client knowledge, and the honest read on whether a draft would survive a client's eyes
Sponsor, rollout phase Practice leadership Authority over the group rollout and the pacing

Objectives and constraints

Scope

In scope: the production of the twice-yearly client deliverables for one advisor, then the rollout of the same capability across the practice. Out of scope: the advice itself, the client relationship, anything a client hears or decides. Those stay human, permanently.

Objective and success criteria

Produce the season's 280 bespoke deliverables with the advisor reviewing instead of producing, against the measured baseline.

Measure Baseline Target Result
Production time per deliverable 1 to 3 hours [Under an hour, reviewing not producing] 15 to 45 minutes
Season production load 280 to 840 hours Fits a working season alongside client meetings 70 to 210 hours
Quality bar Hires' drafts needed rescue edits Corrections are refinements; the advisor signs every deliverable Held. Quality gains are advisor-reported
Operations burden on the practice None existed None created Subscription stack plus skills; nothing for the practice to host

Constraints

  • Bespoke per client. A deliverable that reads as generated fails, whatever it saved.
  • A human reviews every deliverable before a client sees it. Permanent, not a pilot condition.
  • The firm's voice, learned from the firm's own documents.
  • No new operations burden. Advisors advise; nobody becomes a systems administrator.

Architecture and human-in-the-loop design

A living memory system that understands the clients, the CRM, and the portfolios. Custom-built skills on a third-party subscription stack: the practice subscribes to the stack, First Strategy builds and tunes the skills, and there is no system for the client to operate.

The memory holds what the deliverable is actually made of: each client's situation, history, and the read that used to live only in the advisor's head. Production draws on it to draft each seasonal package in the firm's voice. The collaboration design is the load-bearing decision: the system produces the draft and points at exactly what needs human verification, so the advisor's review goes where it matters instead of re-checking everything. Every correction feeds back and improves the next deliverable. Collaborative, not autonomous, by design and permanently.

Current state at the start

Carried from the Day One Audit. 280 clients owed a bespoke deliverable twice a year, one to three hours each, inside a six-week season: 280 to 840 hours of production against perhaps [240 to 360 hours] of one person's capacity. The real system of record was the advisor's memory, which no hire could be trained into. Errors entered through long hours of human production, and paid help existed partly to double- and triple-check the output.

Decision log

When Decision Alternatives rejected Rationale Evidence
Entry Start on a handshake and a monthly retainer The standard fixed-fee Day One and playbook The relationship and trust already existed; the problem was already named Scope converged in a few conversations over two weeks
Interrogate Prove with one real deliverable before building wide Specify the full system first The only test the advisor would trust is a real client document in the firm's voice The first deliverable, two weeks in, judged 90 percent to perfect
Interrogate Kill the template theory; build bespoke per client One strong template, per-client data poured in The advisor required bespoke; a template reads as a form letter to clients who know their advisor Our own intake assumption reversed against real deliverables
Solve Build a living memory as the core Assemble context fresh at production time each season The knowledge, not the document, is the bottleneck; context assembly consumed most of each production hour The audit's root cause
Solve Collaborative review with verification flags Full autonomy; or human re-checking everything Wealth advisory tolerates no ungoverned client-facing output, and undirected checking burns the hours the system saves Review time fell with the flags; a human stayed accountable for every word
Solve Custom skills on a third-party subscription stack Build and host a custom platform Nothing for the practice to operate or maintain The practice runs on a subscription; the skills carry the custom work
Throughout Improve incrementally, deliverable by deliverable Ship one finished system Each increment is judged on a real deliverable; trust accumulates with evidence Two full client cycles of accumulated corrections
Expand Roll out advisor by advisor, deliberately paced Switch the whole practice at once An advisor lost to a bad first draft is lost for good; each memory and voice is its own build 12 advisors live; full practice planned across the next 12 months
Refine Hand the skills to the practice's operations team; step back Remain the permanent operator The goal from the start was to work ourselves out of the job The engagement now runs as occasional improvement calls

The decision and experiment record

The supporting narrative behind the log, across the five canons.

Witness

No floor to walk, so the witness work happened inside the materials: past seasons' deliverables, the CRM, the portfolio platform, and the advisor's account of how a deliverable actually gets made. Two findings shaped everything. First, the real system of record was the advisor's memory; the tools held data, not the read of the clients. Second, our intake assumption that the deliverables were mostly similar was wrong, and the advisor knew it before we did. Bespoke was the product, not the polish.

Interrogate

One experiment carried the phase: produce a single real client deliverable, in the firm's voice, and let the advisor judge it against the bar the hires had failed. Two weeks in, the system returned a deliverable the advisor judged 90 percent to perfect. That moment converted the engagement. The remaining 10 percent became the work: corrections that fed the memory and narrowed with each pass.

Solve

The build ran incrementally on the retainer, one deliverable type at a time, with the advisor reviewing every draft. The verification flags went in early: the system pointed at what needed human eyes, the numbers and the client-specific reads, instead of leaving the advisor to re-check whole documents under deadline. Production per deliverable fell from one to three hours to 15 to 45 minutes. The first full client cycle ran on the system with the advisor's review on everything.

Expand

The second full cycle proved the first was not a fluke and the corrections were compounding: season two's drafts started better than season one's ended. Then the move the first build had earned: the same capability, advisor by advisor, across the practice. Each advisor gets their own client memory, their own voice calibration, and their own review. The rollout stands at 12 advisors, with the full practice planned across the next 12 months.

Refine

For the first advisor, the build phase is over. The engagement moved from building to occasional calls that improve the system, and the path is set to hand the skills to the practice's operations team. Autonomy here does not mean removing the human review; that is permanent. It means the practice owning the capability without us.

The verification design

The wealth advisory analog of an oversight hierarchy is simple and deliberately flat: every client deliverable gets human review before it ships, at every stage of maturity, for every advisor. What graduates is not the oversight but its focus. The system tells the reviewer exactly where to look, and as the memory and corrections accumulate, the flagged items get fewer and sharper. The review never goes away. It gets cheaper.

Risk register

Risk Mitigation Status
A draft reads as generated and a client notices The living memory and the firm's voice, learned from real documents; bespoke per client Held; no template was ever shipped
A wrong number reaches a client Human review on every deliverable, with the system flagging what needs verification Active control, permanent
The advisor loses trust early and the engagement dies First proof on a real deliverable inside two weeks; incremental builds judged on real work Held; the 90 percent moment converted the engagement
The practice inherits an operations burden Subscription stack, custom skills, handover to the ops team In progress by design
The rollout outpaces advisor trust Advisor-by-advisor pacing across 12 months, each with their own memory and review Active; 12 advisors live

Evolution history

When Change Trigger
Entry Handshake scope, monthly retainer Existing relationship; trust already earned
Two weeks in The engagement converts from bet to build The first deliverable judged 90 percent to perfect
First cycle Full season produced on the system, advisor review on everything Solve phase complete against the baseline
Second cycle Drafts open better than the prior season ended; building winds down Corrections compounding in the memory
Now 12 advisors live, full practice over the next 12 months; our role is occasional improvement calls; skills handover to the ops team ahead The first build proved the model for the group

Current status and the autonomy transfer

Two full client cycles delivered on the system. The first advisor runs their season with the system; we are no longer building, we take the occasional call to improve it. The rollout to the practice is running at 12 advisors and growing to the full group over the next 12 months. The skills are tuned by First Strategy today and will be handed to the practice's operations team.

The goal was never to be permanently needed. We worked our way out of the job, which is the outcome we consider success.

Outcomes

  • Production per deliverable: 15 to 45 minutes, from 1 to 3 hours. A 75 percent reduction at both ends of the range.
  • Season production load: 70 to 210 hours, from 280 to 840.
  • The paid double- and triple-checking of output is no longer needed.
  • The advisor's stated wins: sanity, family, time with clients, and the capacity to land new ones.
  • Quality: the drafts improve season over season as corrections accumulate. The quality gain is what the advisors report; we have not measured it independently, and this record says so.
  • The engagement itself: from building, to occasional calls, to a planned handover. 12 advisors live and growing.

Plays

The WISER plays this engagement ran, instantiated with the client's specifics. The high-value plays are held as standalone documents; the rest were applied inline in this Charter. | Canon | Play | What it produced | Source | |-------|------|------------------|--------| | Witness | Documenting Current State, User Flow Mapping | The deliverable trace and the systems landscape, including the memory finding | Inline in the Day One Audit | | Interrogate | Assumption Auditing | The register of intake beliefs, the template theory first, and its reversal | Standalone play | | Interrogate | Experiment Selection | The one-deliverable test that converted the engagement | Inline above | | Solve | Human-in-the-Loop Design | The permanent review with verification flags, and the correction loop | Standalone play | | Solve | Quality Objective Setting, Value Validation | The success criteria and the measured 75 percent reduction | Inline above | | Expand | Expansion Sequencing | The advisor-by-advisor rollout order and pacing | Standalone play | | Refine | Graduation Decision Making | The narrowing of verification focus and the handover path to the ops team | Inline above |

The first season is solved and the practice is adopting the capability. The difference from where this started is not just the recovered hours. The practice now holds, in a system, the thing that used to live in one head at a time.

INTERROGATE

Assumption Register

Interrogate play, instantiated for the financial services and wealth advisory engagement. Purpose: surface the assumptions to test before committing to a build, including the ones we carried in ourselves. Each gets a cheap test and a clear bar for proof.

Killed Most clients need similar deliverables Our intake assumption: one strong template, per-client data poured in. Reversed against real deliverables. Bespoke is the product, not the polish.
Confirmed A system can hit the firm's voice and the advisor's bar The core bet of the engagement. One real client deliverable, two weeks in, judged 90 percent to perfect by the advisor.
Reframed The constraint is production capacity The hiring attempt assumed more hands would fix the season. The constraint is the client knowledge in one head. Hands without the knowledge produce correct, generic documents.
# Assumption Source Cheap test What proves or kills it
1 Most clients need similar deliverables Our own intake read Hold the template theory against real past deliverables and the advisor's read of them Killed if the client-specific shaping is load-bearing in each one; it was
2 A system can hit the firm's voice and the advisor's bar The engagement's core bet Produce one real client deliverable and let the advisor judge it against the bar the hires failed Proven if the corrections are refinements, not rescues; killed if it reads as generated
3 The constraint is production capacity The failed hiring attempt Trace one deliverable end to end and find where the hours actually go Reframed: most of each hour was context assembly and checking, which hands cannot absorb without the knowledge

Why assumption 1 is tested at all: it was ours, and it is the industry's default fix. Killing it directly, against real documents, is what pointed the build at a living memory instead of a template engine.

Results are recorded in the Charter's decision log.

SOLVE

Human-in-the-Loop Design

Solve play, instantiated for the financial services and wealth advisory engagement. Purpose: define who reviews AI output, how, and what gets logged, so a human directs the AI rather than the reverse. In wealth advisory the design is permanent: a person stays accountable for every word and number a client sees, at every stage of the system's maturity.

Memory assemblesthe client's situation, CRM, portfolio AI draftsthe deliverable, in the firm's voice Advisor reviewsdirected by the verification flags Client receivespresentation and report

Every correction feeds the memory. The next deliverable opens better, and the flags get fewer and sharper.

The advisor reviews every deliverable. The system's job is to make that review cheap: it points at exactly what needs human verification, the numbers and the client-specific reads, instead of leaving the advisor to recheck whole documents under deadline.

Element Design
Who reviews The advisor, on every deliverable, permanently
What they check The flagged items first: figures, client-specific reads, recommendations. Then the final read for voice and fit
What gets logged Every correction, with what the draft got wrong
What the log feeds The living memory. Corrections accumulate, so drafts improve season over season
Accountability The advisor signs every client-facing document. The system never sends anything

What graduates, and what never does

The review never goes away. That is the design, not a maturity stage; this is wealth advisory, and the advisor's accountability to the client is the business. What graduates is the review's focus: as the corrections accumulate and the memory sharpens, the flags narrow from many items to few. The review gets cheaper, never optional.

Why this matters

The double- and triple-checking the advisor used to pay for was undirected verification: rechecking everything because nothing said where the risk was. The flags are directed verification. The same accountability, a fraction of the hours, and the difference between the two is most of what turned one to three hours per deliverable into 15 to 45 minutes.

EXPAND

Expansion Sequencing

Expand play, instantiated for the financial services and wealth advisory engagement. Purpose: order the rollout from the proven context to genuinely new ones, with a gate at each step, so the expansion runs on evidence instead of enthusiasm.

One advisor280 clients, the hardest case Second seasonproof it was not a fluke 12 advisorseach with their own memory and voice Full practiceover the next 12 months

Each advisor is a contained deployment. The pacing is deliberate: an advisor who distrusts the first draft is lost for good.

The first build was deliberately the hardest version of the problem: 280 bespoke deliverables in a six-week season. A system that holds there does not need to be re-proven for lighter loads. What does need proving, advisor by advisor, is trust.

Stage What deploys The gate before advancing
One advisor The full build: memory, production, verification flags A full season produced on the system, against the one-to-three-hour baseline
Second season The same system, second full cycle Drafts opening better than the prior season ended; corrections compounding
12 advisors A memory, voice calibration, and review per advisor Each advisor's first drafts pass their own review; no advisor inherits another's calibration
Full practice The remaining advisors, over the next 12 months The pacing holds; the practice's operations team takes the skills as the handover lands

What does not transfer

The system transfers. The memory does not. Each advisor's client knowledge, voice, and judgment is its own asset, built and calibrated per advisor, reviewed by that advisor. Treating the rollout as one deployment instead of many small ones is the failure mode this sequencing exists to prevent.

Where each of these started.

Every one of these engagements started with a day. A fixed-fee day in the business with leadership. Real work, not slides. A playbook within two weeks. Then a decision.

Start with a Day One

Where to from here.

Start with a day.

A fixed-fee day in your business with your leadership. Real work, not slides. A playbook within two weeks. Day One.

Tell us what you're working on.

Already know you want a build, or have a problem that does not fit Day One? Inquire.