The advocate's letter arrived on a Thursday. It asked a single, devastating question about a fourteen-year-old's dependency case: "On what authority, and under what written rule, did your agency use an artificial-intelligence tool to help draft the court report that recommended my client's children remain in placement?" The agency director read it twice. She knew, generally, that caseworkers in two of her five units used an AI documentation tool. She knew, generally, that a screening pilot was running in intake. She did not have a single document she could hand the advocate that said what was permitted, what was forbidden, who was accountable, and how the work was checked. Each unit had improvised its own practice. The eligibility office had one understanding of the rules, the child-welfare unit another, the intake desk a third. There was no policy. There was a collection of habits. And a habit, the director understood as she drafted her reply, is not something you can defend to a court, an advocate, or an oversight body. A written policy that holds across every program is the document every AI decision in the agency can be checked against. Her agency did not have one, and the absence had just become a legal exposure with a child's life attached to it.

Why One Policy, Not Five Practices

Most agencies do not arrive at AI through a deliberate decision. They arrive at it through drift. A vendor adds an AI feature to the case-management system the agency already owns. A supervisor in one unit hears about a transcription tool at a conference and starts a quiet trial. The eligibility office gets a new automated rules-engine bundled into a benefits-determination platform. Each adoption is local, each is reasonable on its own terms, and none of them was governed by a rule that applied to the others. The result is what the opening story describes: a single agency operating four or five different unwritten AI practices, none of which can be audited because none of them was ever written down.

This matters because the failure modes of AI in human services do not respect organizational boundaries. A hallucinated observation (a clinical detail a large language model invents and states in confident professional prose) is the same structural risk whether it appears in a child-welfare court report or a Supplemental Nutrition Assistance Program (SNAP, the federal food-assistance benefit commonly called food stamps) case note. The risk that an automated rules engine misapplies a policy is the same risk whether the program is Medicaid, Temporary Assistance for Needy Families (TANF, the federal cash-assistance program), or a housing voucher. A risk-screening tool that encodes the inequities in its training data does so identically in intake and in eligibility. If each unit invents its own rules, the agency catches the same failure mode well in one place and misses it entirely in another, and it has no consistent answer when an advocate, a court, or a state oversight reviewer asks how the work is governed.

An enterprise AI policy is the single document that holds across documentation, eligibility, screening, and navigation. It is not a vision statement and not a vendor brochure. It is an operational rulebook: a worker in any unit can open it and learn what they are permitted to do with AI, what they are forbidden from doing, what they must verify, and what they must record. A supervisor can audit against it. A director can defend the agency with it. An advocate can hold the agency to it. The test of whether a policy is real is simple: can a caseworker who has never met you read it and know exactly where the lines are. If the answer is no, the agency is still running on habit.

A habit cannot be audited and cannot be defended. A written policy that holds across every program is the document every AI decision in the agency can be checked against.

The Spine the Policy Must Encode

A human-services AI policy is not a generic technology-acceptable-use document with the word "AI" pasted in. It must encode the non-negotiables that govern this field specifically, because the consequences here are removal of a child, substantiation of a report, and denial of food or shelter, not a slow login or a misrouted email. Five principles form the spine, and every operational rule in the policy descends from one of them.

AI informs, humans decide. The cardinal rule must appear as the policy's first substantive clause, not as an aspiration but as an enforceable boundary. The policy states plainly that no consequential determination (to remove a child, substantiate a report, approve or deny a benefit, prioritize a placement) may be made by an AI system, and that "the model said so" is never a sufficient basis recorded for such a decision. The named accountable human (the caseworker, the supervisor, the determining officer) owns every consequential call. A policy that leaves this implicit invites exactly the drift that produces an automated denial nobody will stand behind in a fair hearing.

Grounded generation, never free generation. The policy must require that any AI-drafted document (a case note, a court report, an intake summary) be grounded in the actual record and that the model is forbidden, by instruction and by tool selection, from inventing observations. The note becomes a legal record, so the standard is grounded generation: the model summarizes and organizes what is in the file and the worker's own field notes, and it does not add what is plausible but undocumented.

Verification to a court-record standard. The policy must state that every AI-touched factual claim is verified against an independent source before the document is filed, and it must define what verification means rather than merely requiring people to "be careful." For an agency of fifteen caseworkers each carrying twenty to thirty families, an undefined verification requirement is a requirement that quietly disappears under caseload pressure. The policy makes verification a named, checkable step.

Equity first, continuously. The policy must treat every risk signal as one audited input under mandatory human review and require equity auditing as a continuing practice, not a one-time sign-off at procurement. History (the long public debate over the Allegheny Family Screening Tool, the wrongful fraud accusations in Michigan's MiDAS unemployment system, and the Dutch childcare-benefits scandal that forced a national government to resign) proves these tools can encode and amplify inequity. The policy names equity auditing as an ongoing obligation with an owner.

Due process and privacy as the perimeter. The policy must protect notice, the right to a fair hearing, and the right to challenge a determination, and it must protect the most sensitive data the government holds. It must require disclosure of AI use where due process demands it, so the work stays defensible to a court and an advocate. These are not technology rules. They are the rights perimeter inside which any technology rule must sit.

What the Policy Actually Says, Section by Section

Principles are the spine. A usable policy translates each principle into a rule a tired caseworker can follow at 9 p.m. and a supervisor can audit against the next morning. A complete enterprise AI policy for a human-services agency contains, at minimum, the following sections.

Scope and Definitions

The policy states which tools, programs, and roles it covers, and it defines its terms in field language. It says explicitly that it covers AI features embedded in the case-management system, not only stand-alone tools, because the most common way AI enters an agency unnoticed is bundled into a platform the agency already owns. It defines hallucination, decision-aid, grounded generation, risk signal, and equity audit so that a worker in the eligibility unit and a worker in intake mean the same thing by the same word. Ambiguous scope is how a policy ends up governing four units and silently exempting the fifth.

Permitted and Prohibited Uses

This is the section a worker reads first, and it must be concrete. Permitted, with verification: AI-assisted drafting of a case note from the worker's own field notes; AI summarization of a long record the worker has read; AI-assisted plain-language rewriting of a client letter; AI-assisted research into which program a resource navigation referral fits. Prohibited outright: entering identifying client data into a consumer AI tool that is not covered by the agency's data agreement; using AI output as the recorded basis for a consequential determination; filing any AI-drafted document without claim-by-claim verification; treating a risk score as a decision. The contrast between the two lists is the heart of the policy. A worker who has read it knows that drafting a note from their notes is encouraged and that pasting a family's case history into a public chatbot to "get a second opinion" is a fireable violation, not a clever shortcut.

The Verification Standard

The policy defines verification operationally so it cannot evaporate. For observations: every specific detail in an AI draft is traced to the worker's own field notes, and any detail that does not appear there is removed, not softened. For policy claims: the rule is checked against the current policy manual or regulation, never against the AI that generated it. For history: each referenced prior incident, service, or finding is traced to a specific entry in the case-management system. The policy states who performs verification (the worker who files the document), who audits that it happened (the supervisor), and that the time AI returns from drafting is allocated to verification and to direct family contact, not absorbed into a higher caseload. A verification rule that does not protect the time to verify is a rule that will be skipped.

Equity and Screening Controls

For any AI that screens, scores, or ranks, the policy mandates that the output is one input under mandatory human review, that the human review cannot be skipped under caseload pressure, that the worker records how the signal informed and did not decide the judgment, and that the tool is subject to a scheduled equity audit owned by a named role. The policy states what happens when an audit finds disparity: the tool is paused, not merely noted. An equity provision with no consequence is decoration.

Privacy, Disclosure, and the Audit Trail

The policy names what data may touch which tools, what must be logged for every AI-assisted record (which tool, which version, what was generated, who verified it, who decided), and when AI use must be disclosed to a client, a court, or an advocate. The logging requirement is what lets the agency answer the advocate's letter from the opening: a court-defensible audit trail reconstructs every AI-touched note so the work withstands review. Without it, the agency is again defending a habit.

Roles, Enforcement, and Incident Response

The policy names who owns it, who enforces it, what happens when it is violated, and what the agency does when an AI tool causes a case problem. It is not enough to publish rules. The policy assigns an accountable owner (often an agency AI lead), defines the supervisor's audit duty, states the consequence for a violation in the same terms as any other professional-conduct breach, and describes the incident-response path when a hallucinated observation reaches a court or a wrong eligibility rule reaches a family. A policy with no enforcement and no incident path is a wish.

Making the Policy Hold Across Programs

The hardest part of an enterprise policy is not writing it. It is making one document genuinely govern four very different kinds of work. The risk in child welfare is a fabricated observation that separates a family. The risk in eligibility is a misapplied rule that denies food or shelter. The risk in screening is encoded inequity that flags families by proxy for poverty or race. The risk in resource navigation is sending a person in crisis to a program that closed last month. These are different failure modes with different harms, and a policy written for only one of them will fail the others.

The way a single policy holds across all four is to make the principles uniform and the controls program-specific. The cardinal rule, the verification requirement, the equity-audit obligation, and the audit-trail standard are identical everywhere: no exceptions, no unit gets to opt out, no program is "low-stakes enough" to skip verification. But the policy attaches a program-specific control set to each domain. The documentation control set centers on grounded generation and claim-by-claim verification against field notes and the record. The eligibility control set centers on checking the applied rule against the current regulation and protecting the right to a fair hearing. The screening control set centers on mandatory human review and scheduled equity auditing with a pause-on-disparity trigger. The navigation control set centers on a freshness check that a referred resource is currently available before it reaches a client.

Consider the eligibility office under this structure. A worker uses the benefits platform's AI to apply SNAP rules to a household that includes a child receiving Supplemental Security Income (SSI, the federal disability and aged-assistance benefit). The platform returns a denial on a gross-income test. Under the enterprise policy, the same cardinal rule that governs the child-welfare unit applies here: the worker, not the platform, owns the determination, and the policy's eligibility control set requires the worker to check the applied rule against the current manual. The worker does, finds the household is categorically eligible through the SSI member so the gross-income test does not apply, and reverses the draft denial before it ever reaches the family. One policy, one cardinal rule, one verification discipline, applied through a control set tuned to the program. That is what "holds across programs" means in practice: a family kept fed by the same document that protects a child in dependency court.

A policy that holds also has to survive contact with caseload reality. The most common way an enterprise policy fails is not that workers disagree with it; it is that the agency deploys the AI tools without protecting the time the policy's verification standard requires. If documentation moves faster but the saved hours are immediately filled with more cases, the verification step becomes the thing that gets dropped at 9 p.m., and the policy becomes a document the agency violates daily while pointing to it as evidence of diligence. A real enterprise policy is paired with a staffing and caseload commitment that makes compliance physically possible. The policy and the operating conditions are one system; writing the first while ignoring the second produces a defense that collapses the moment an advocate examines what actually happened in the case.

Keeping the Policy Alive

An enterprise AI policy is not a document you write once and frame on a wall. The tools change, the regulations change, the vendors push updates, and the failure modes the field discovers this year were not visible last year. A policy that is not maintained becomes inaccurate, and an inaccurate policy is worse than none, because the agency points to it as evidence of governance while the actual practice has drifted past what it says.

Keeping the policy alive means a named owner reviews it on a fixed schedule, at minimum annually and immediately after any significant tool change or any incident. It means the equity audits feed back into the policy: when an audit finds a disparity, the control that failed is strengthened in the written rule, not just fixed quietly in one unit. It means new tools cannot be deployed until they are mapped to the policy's permitted-use and control sections, so the agency never again accumulates the unwritten practices that produced the opening crisis. And it means the policy is trained, not merely published. A caseworker who has never read the policy is governed by habit regardless of what the document says, so the policy is taught in onboarding, reinforced in supervision, and tested in the same way the agency tests any other competency that protects the people it serves.

There is a measure of a living policy that a director can feel. When the next advocate's letter arrives asking on what authority and under what written rule the agency used AI in a case, the director can answer in one move: she hands over the policy, the permitted-use section that authorized the use, the verification record showing the work was checked, and the audit-trail entry showing a named human made the call. The question that was a legal exposure becomes a demonstration of governance. That is the entire purpose of the document. It converts AI use from an indefensible habit into a defensible, auditable practice that a court, an advocate, and the people the agency serves can hold it to.

Key Takeaways

• Agencies usually arrive at AI through drift, not decision, ending up with four or five unwritten unit practices that cannot be audited or defended. An enterprise AI policy is the single written document every AI decision across documentation, eligibility, screening, and navigation can be checked against.
• The policy must encode the field's five non-negotiables as enforceable rules: AI informs and humans decide; grounded generation never free generation; verification to a court-record standard; equity first and continuous; and due process and privacy as the perimeter.
• A usable policy translates each principle into concrete sections: scope and definitions, permitted and prohibited uses, a verification standard defined operationally, equity and screening controls, privacy and disclosure and the audit trail, and roles, enforcement, and incident response.
• The permitted-and-prohibited section is the heart of the policy. A worker must be able to read it and know that drafting a note from their own field notes is encouraged while pasting a family's case history into a public chatbot is a fireable violation.
• One policy holds across four different kinds of work by keeping the principles uniform (no unit opts out of the cardinal rule or verification) while attaching program-specific control sets to documentation, eligibility, screening, and navigation, each tuned to that domain's failure mode.
• The policy must protect the time its verification standard requires. If AI speeds documentation but the saved hours are absorbed into a higher caseload, verification gets dropped under pressure and the policy becomes a document the agency violates daily.
• The audit trail (which tool, which version, what was generated, who verified, who decided) is what lets a director answer an advocate or a court by handing over the policy, the verification record, and proof a named human made the call, converting a legal exposure into a demonstration of governance.
• A policy must be kept alive: a named owner reviews it at least annually and after any tool change or incident, equity audits feed corrections back into the written rule, new tools are mapped to the policy before deployment, and the policy is trained and tested, not merely published.