AI uses for records
How to write SOPs that AI agents can follow
By SourceX Editorial · Updated
Short answer
To write SOPs that AI agents can follow, give every step one action, named inputs, an explicit decision rule with an else branch, listed exceptions and a human owner for anything outside the rules. AI-ready SOPs remove guesswork: if a new hire would need to ask a colleague, an agent will guess, so write the answer into the step.
Key takeaways
- Write one action per step, and name the system and field that action touches.
- Turn every judgment word such as large, urgent or unusual into a rule tied to a field value or a named list.
- List the known exceptions for each step and say which role receives the case when none applies.
- Test an SOP by replaying closed cases from your ticket or job history and checking whether the steps reach the recorded outcome.
- SOPs paired with records of how the work was actually done are more useful to AI developers than SOPs alone.
What makes an SOP ready for an AI agent?#
An AI-ready SOP is a procedure that states every input, action, decision and handoff explicitly, because an agent cannot fill gaps with hallway knowledge. Most existing SOPs were written for trained staff who already know the systems, the customers and the unwritten rules, so they skip exactly the details an agent needs.
The gap is usually not missing steps but missing conditions. A line such as escalate if the customer seems upset assumes a judgment the agent cannot make consistently. A line such as escalate when the ticket has been reopened or the account is on the priority list gives the agent something it can check.
| Element | Written for people | Written for an agent |
|---|---|---|
| Trigger | When a callback comes in | When a job is created with job type Warranty Callback in the field service system |
| Inputs | Pull up the customer's history | Open the customer record, the original install job, its invoice and the equipment record |
| Decision | Use your judgment on coverage | Covered if the install date on the equipment record falls inside the warranty term and no exclusion note exists |
| Exception | Ask a supervisor if unsure | If the equipment record is missing, assign to the service manager queue with reason No Warranty Record |
| Owner | The service team | Service manager owns the SOP; the dispatch lead approves changes |
| Done state | Get it scheduled | Job scheduled, technician assigned, customer notified, warranty flag set on the job |
The fields every agent-ready step needs#
Every agent-ready step needs the same small set of fields, written in the same order each time. Consistency matters as much as completeness: when every step follows one pattern, an agent and a human reviewer can both see at a glance what is missing.
Keep each step to a single action. Combined steps such as verify the order and issue the credit hide a decision between two actions, and that hidden decision is where agents go wrong.
- Step name: a short verb phrase, such as Confirm warranty coverage.
- Trigger or precondition: the event or record status that starts the step.
- Inputs: the records, systems and fields the step reads, by their real names.
- Action: one thing the agent does, in one system.
- Decision rule: the condition written as if this, then that, with an else branch.
- Exceptions: known cases the rule does not cover, and where each one goes.
- Output: which record changes, which field gets set and what note is written.
- Owner: the role that answers questions and approves changes.
- 01Your work records
- 02Personal details removed
- 03You approve the release
- 04Licensed to AI developers
How to write decision points an agent cannot misread#
Decision points become reliable when every condition refers to something the agent can look up: a field value, a status, a named list or a referenced document. Words like reasonable, significant and promptly read clearly to people and mean nothing to software.
Write the else branch every time. Many SOPs say what to do when a condition is true and stay silent otherwise, which leaves the agent to improvise. If there is genuinely no rule, say so and route the case to a named queue.
Where a threshold comes from policy, point to the policy rather than copying the value. If the approval limit for customer credits lives in a finance policy, reference that document so a later change does not leave two conflicting versions.
| Vague phrase | Rewrite an agent can check |
|---|---|
| A large order | An order whose total exceeds the credit limit on the customer record |
| Contact the customer promptly | Send the confirmation template before closing the step |
| A repeat problem | A second job at the same address for the same equipment inside the warranty term |
| If something looks wrong | If the invoice total differs from the approved estimate total on the job |
| Get approval | Request approval in the approvals queue and wait for an Approved status |
Exceptions and escalation: where most SOPs go quiet#
Exceptions and escalation paths are where most SOPs go quiet, so an agent-ready SOP lists the exceptions the team already knows about and gives each one a destination. Routine cases rarely need a document at all; the unusual ones are where an agent needs instructions.
The best source for that list is your own history. Closed tickets, job notes, credit memos and reopened cases show the situations staff actually handled outside the standard path, and reading a sample before you write usually surfaces exceptions nobody remembered to document.
Always end with a catch-all: when no rule and no listed exception applies, the agent stops, records what it saw and hands the case to a named role. An agent that knows when to stop is safer than one that tries to finish everything.
Illustrative: rewriting a warranty callback SOP#
Illustrative: a fictional heating and cooling contractor serving homeowners keeps its jobs, invoices and equipment records in one field service platform and wants an agent to triage warranty callbacks before dispatch. The before version of its SOP is one paragraph: check whether the job is under warranty, schedule it if so, and talk to the service manager if anything is unclear.
The after version, written by the operations lead, splits that paragraph into six single-action steps. Each one names its inputs, its rule, its else branch and where exceptions go, including a missing equipment record, a homeowner who bought the house after installation, and a callback that follows another contractor's repair.
Before switching anything on, the team replays closed callbacks from the platform's history through the new steps. Most reach the outcome the dispatcher recorded; the ones that do not reveal two unwritten rules, which are added to the SOP. The agent goes live on triage only, and the service manager still approves every no-charge visit.
- Step 1, Find the original job: when a job is created with job type Warranty Callback, read the linked install job number; if none is linked, route to the service manager queue with reason No Install Job.
- Step 2, Check the equipment record: open the equipment record attached to the install job; if it is missing, route to the service manager queue with reason No Warranty Record.
- Step 3, Check the warranty term: if the install date falls inside the warranty term on the equipment record, continue; else set the job to billable and send the standard out-of-warranty template.
- Step 4, Check ownership: if the customer record shows a different homeowner from the one on the install job, route to the service manager with reason Ownership Change.
- Step 5, Check prior repairs: if job notes show another contractor worked on the unit after installation, route to the service manager with reason Third-Party Repair.
- Step 6, Hand off to dispatch: set the warranty flag, apply the callback priority from the dispatch policy, and write the rule that decided the case into the job notes.
How to test an SOP before an agent runs it#
Testing an SOP before an agent runs it means checking the steps against real cases, not just reading them for clarity. A procedure can read well and still fail on the first unusual job.
Keep the test cases afterward. A small set of closed cases with known outcomes becomes a regression check you can rerun whenever the SOP, the system or the agent changes.
- Hand the SOP to someone outside the team and ask them to work through recent cases without asking questions; every question they want to ask marks a gap.
- Replay closed cases from your ticket, job or order history and compare where the steps lead with the outcome actually recorded.
- Include cases that were reopened, credited or escalated, because they exercise the exception paths.
- Check every system and field name against the live system, since a renamed field breaks an agent silently.
- Record the SOP version and date so later results can be traced to the version in force.
Mistakes that make SOPs fail with agents#
The mistake that most often makes SOPs fail with agents is documenting the ideal process rather than the real one. If staff routinely skip a step or use a workaround, the agent will follow the document and produce results nobody expects.
Other frequent problems are screenshots without text, steps that depend on an attachment the agent cannot open, references to people by first name instead of role, and the same SOP stored in several places with different versions. Pick one home for each SOP, retire the copies, and write every instruction in text even when a screenshot helps people.
Why SOPs paired with records interest AI developers#
SOPs paired with the records of how work was actually done interest AI developers because together they show the intended procedure and the real decisions, exceptions and outcomes. An SOP alone describes a process; the matching tickets, jobs or orders show how people applied it, where they departed from it and what happened next.
SourceX treats procedure documents as part of a wider record family rather than as standalone files. Through the SourceX five-step transaction (Supply, Rights, Preparation, Approval and Delivery), a company first describes its SOPs and linked systems using metadata only, and rights review, privacy preparation and the company's own approval come before anything is delivered. Every licensed package is documented in a SourceX Evidence Packet, which sets out where the procedures and records came from (provenance), the licensing rights behind them, the permitted use, the privacy record and who authorized release. Any such package is licensed, not sold, and the company keeps ownership of its records.
What is an AI agent skill, and how is it different from an SOP document?#
An AI agent skill is a folder that packages the instructions for one task so an agent can load them when that task comes up; at minimum it holds a SKILL.md file with a name, a description and the instructions. The Agent Skills format was originally developed by Anthropic and released as an open standard, and a skill can also bundle scripts, reference documents and templates.
The practical difference from an SOP sitting in a wiki is how the agent finds it. Agents load only each skill's name and description at startup, read the full SKILL.md when a task matches the description, and open bundled files only when a step needs them. An agent-ready SOP becomes the body of the skill, and the description decides whether the agent ever reaches for it.
| Agent-ready SOP part | Where it goes in a skill | What to watch |
|---|---|---|
| SOP title | The name field | Up to 64 characters, lowercase letters, numbers and hyphens only, matching the folder name |
| Trigger or precondition | The description field | Up to 1,024 characters; say what the skill does and when to use it, with specific keywords |
| Steps, decision rules, exceptions and catch-all | The SKILL.md body | Keep the main file under 500 lines, since the whole body loads once the skill activates |
| Referenced policy, such as a credit approval limit | A file in the references folder | Link it from SKILL.md, one level deep, rather than pasting the value |
| Customer message templates and lookup lists | A file in the assets folder | Templates and data files load only when a step calls for them |
| Owner and SOP version | The metadata field | A simple map of keys to text values, such as owner and version |
How do you test an SOP once it is packaged as a skill?#
Test a skill by running the same realistic requests with the skill and without it, then comparing the results. The Agent Skills documentation calls these evals and suggests keeping the test cases in an evals/evals.json file inside the skill folder, each with a prompt, a description of the expected output and any input files.
- Start with two or three of your closed replay cases, rewritten as the requests staff would actually type.
- Include at least one boundary case, such as a callback with no equipment record, because edge cases expose ambiguous instructions.
- When the agent makes a mistake you have to correct, add the correction to the skill as a known gotcha and rerun the cases.
- Load procedure skills only from a repository your team controls; the client guidance warns that skills in an untrusted repository can silently inject instructions into an agent.
Is packaging an SOP as a skill the same as licensing it as AI data?#
No. A skill puts your procedure to work inside agents, while licensing gives an AI developer contractual rights to use SOPs to build or evaluate its own models. The two can coexist, but they raise different questions about what leaves the company and on what terms.
A skill's optional license field states terms for the skill itself; it is not a data license covering permitted use, privacy handling and who approved release. When SOPs are licensed through SourceX, the company approves exactly what is released, once per deal, before anything is shared. This is general information, and counsel should review the specific terms.
| Question | Skill used internally | Skill shared outside the company | SOPs licensed as data |
|---|---|---|---|
| Who uses it | Your own agents and staff | Other teams or companies running their own agents | An AI developer building or evaluating models |
| What leaves the company | Whatever your agent platform's terms already cover | The skill folder, including scripts and reference files | An approved package of procedures and linked records |
| What governs use | Internal policy and the SOP owner | The license you state for the skill | A negotiated data license with named permitted uses |
| What to check first | Field names, versions and where the skill is loaded from | Whether it exposes internal policies, thresholds or customer details | Rights, privacy preparation and consent, reviewed by counsel |
Sources for this section
- The Agent Skills overview defines a skill as a folder containing a SKILL.md file with metadata and instructions, loaded through progressive disclosure, and notes the format was developed by Anthropic and released as an open standard. Source
- The Agent Skills specification sets the name and description limits, the optional license and metadata fields, the references and assets folders, and recommends keeping SKILL.md under 500 lines. Source
- The Agent Skills evaluation guide recommends running test cases with and without the skill, stored in evals/evals.json, including at least one boundary case. Source
- The Agent Skills best practices guide recommends adding corrections to a skill's gotchas section when an agent makes a mistake. Source
- The Agent Skills client guidance recommends gating project-level skills on a trust check so untrusted repositories cannot silently inject instructions. Source
Frequently asked questions
Do agent-ready SOPs need a special file format?
No special format is required, but consistency helps. Plain structured text with the same field labels in every step works better than free-form prose, slide decks or screenshots. Store each SOP in one system your agent can read, such as a wiki or document repository, and keep the version and owner at the top.
Should we keep separate SOPs for people and for agents?
Usually one version is better. An SOP clear enough for an agent is also clearer for new staff, and maintaining two versions invites drift. Where people need extra context, such as tips or screenshots, add it beneath the structured steps rather than in a separate document.
Can AI draft SOPs from our existing tickets and notes?
AI tools can produce a useful first draft by summarizing how closed cases were handled, but the draft reflects whatever patterns appear in the records, including bad habits. Treat it as raw material: an experienced operator should confirm each decision rule and exception before the SOP is approved.
Who should own an agent-ready SOP?
A named role close to the work, such as a service manager or AP supervisor, should own the content, with a second role approving changes. Ownership matters more once an agent follows the SOP, because an outdated step now repeats on every case instead of being quietly corrected by experienced staff.
How often should agent-ready SOPs be reviewed?
Review them whenever the underlying system, policy or team changes, and on a regular schedule set by the owner. Rerunning the saved test cases after each change is a quick way to confirm the SOP still leads to the outcomes your records show.
Related resources
- IndustryHealthcare data
- IndustryConstruction data
- QuestionDo AI companies buy private business data?
- QuestionPublic data vs proprietary data: what's the difference for AI?
- InsightCan restaurants and hospitality groups sell their data to AI companies?
- InsightCan SaaS companies sell their data to AI companies?
See if your company qualifies
A short company assessment. No data uploads are needed.