You finished Part 4 with a working agent — instruction, context, iterated example, saved under a clear name. What you don't have yet is a system.
The math. One agent saves about 15 minutes per client per month. A three-agent chain saves closer to two hours. Across 30 clients that's 60 hours a month — most of a half-FTE returned. But the math only works if the agent persists, ports, and composes — and most practitioners haven't designed for any of those.
Part 5 of a five-part series. Part 1 covered what an agent is, Part 2 where to place your first, Part 3 built the client context file, Part 4 assembled and iterated a working agent. This piece turns one agent into a system.
Persist, port, and compose — the three operational AI disciplines
Three things have to happen for a single agent to become practice infrastructure. It persists across time — saved, named, opened again next month. It ports across clients — same instruction, next name on your book. It composes with other agents into chains.
Each is operational, not conceptual, and each forces a concrete tool decision. This is where the series stops being tool-agnostic.
Lifecycle — the agent has to outlive the chat
The requirement is platform-independent: persistent instruction, attached context, baked-in example. Microsoft Copilot Agents, Gemini Gems, ChatGPT Custom GPTs, and Claude Cowork Skills all clear that bar. Names and capabilities will keep moving as vendors iterate; the requirement won't. Pick the one your firm already pays for, build the agent there, and run it next month without starting over.
Saving as a skill is the entry point. Bundling skills into a Cowork plugin — with a manifest, supporting context, and an installable wrapper — is the next step, and it's what the From Agent to Asset module teaches inside AI Essentials.
Replication — same agent, next client
This is where platforms diverge. Claude Cowork has the cleanest replication story — your context file lives as a real file on your computer, and swap means starting the skill in a different folder. The per-client context library from Part 3 maps directly onto your folder structure. For Microsoft Copilot, Gemini, and ChatGPT, the workaround is to drop the context file — Word doc, markdown, plain text — into the chat at the start of each run. The file enters working memory, the agent operates against it — same effect, different mechanism.
Practical recommendation: maintain a per-client context-file library. Ten seconds per swap. Same instruction, fifty context files, fifty working agents — the second axis of compounding from Part 3, in motion.
The From Agent to Asset module makes this systematic — connectors pull the per-client data live, and shared plugin distribution moves the model from "ten seconds per swap, one operator" to "anyone on the team can install and run." Same compounding axis, firm-wide reach.
Composition — manual chain, no shame
Output of one agent becomes the input of the next. The realistic starting point is the manual chain: run Agent 1, copy the output, paste into Agent 2, run, copy, paste into Agent 3. One operator, one LLM, three runs. Automation options exist for later — but most CAS practices will manually chain for the next 12 to 18 months, and that's better than not chaining at all.
When you're ready to graduate from copy-paste — and you don't have to be — the From Agent to Asset module is where the manual chain becomes a packaged plugin with live connectors and deterministic checks. The manual chain isn't a stepping stone you grow out of; it's a working production pattern. From Agent to Asset is the next maturity step for the firms ready to invest in firm infrastructure, not a correction to the approach in this article.
Worked example — three-agent document collection
Take Glendale Brewing again. The doc-chase agent from Part 4 is Agent 3. We need two more in front of it.
Agent 1 — Expected checklist generator. Reads the context file and the prior month's working papers, produces the checklist of what we expect: bank statements, payroll reports, sales summaries, any irregular items.
Agent 2 — Outstanding-list builder. Reads Agent 1's checklist and this month's received-documents list, produces the gap.
Agent 3 — The doc-chase agent. Already built. Input: the outstanding list from Agent 2.
Total operator time on the manual chain: about ten minutes. Total work delivered: an expected checklist, a tagged outstanding list, and a client email already sent — work that used to take a morning.
One assumption worth naming. The chain only works if your agent can read the prior month's working papers and this month's received-documents list. Claude Cowork has file-system access; Copilot can interrogate SharePoint or OneDrive folders linked into chat; Gemini does the same with Drive; ChatGPT is weakest here — typically you upload files at runtime. Connectivity from your LLM to your client-file storage is one of the harder parts of building real agents — and what distinguishes a working chain from a demo.
Exposing your working files to an agent feels risky, and it is. It's also where the largest gains come from. Deprive an agent of real data and real context, and you won't get real answers.
Try this now — 60 minutes, one client
Pick one client and one cycle — monthly close, quarterly review, year-end, tax filing, any recurring engagement. Sketch the three agents the cycle needs. Build the first two using the iteration mechanic from Part 4. Agent 3 is the doc-chase agent or your cycle's equivalent — bookkeeping cycles end in a chase, tax cycles in a filing checklist or client-confirmation request, advisory cycles in a board-packet narrative.
Run the chain end-to-end on one client. The same chain applies to the next client by swapping context files.
From one agent to a working practice
You started Part 1 with one paragraph. You finish with a working three-agent chain that saves two hours per client per month and ports across your book. Five exercises, soon bundled as the Agent Builder Workbook.
The series ends here. The shift from "how do I build agents" to "how do I run a practice on them" is what AI Essentials covers — and the From Agent to Asset module picks up exactly where this manual chain ends. Six sessions that take the same Glendale chain from copy-paste to a packaged Cowork plugin, connected to live data, with deterministic checks, distributed to the team. Guided implementation, monthly live calls, and curated workflows that turn the exercises into firm-wide capability.
If you're ready to turn the work you've done across this series into firm infrastructure, explore AI Practice Transformation — the engagement that takes the Agent Builder system and embeds it into the way your practice runs.