Scope the Function First

This is step 1 of 4 in designing a digital workforce. Before any agent is defined, you pick one business function and answer three questions about it. Your answers become the design brief that everything else in this stage is built on.

What you will be able to do

• Choose a scope narrow enough to design against
• Answer the three scoping questions for a function you own
• Break a scoped function into its actual responsibilities

Pick One Function, Not the Whole Company

Pick one business function. Not "the whole company." One domain.

The temptation runs the other way. An organization-wide AI program sounds more ambitious than a scoped one, so the scope starts at everything and never narrows to something you can write a job description against. You cannot name outputs for "the whole company." You can name them for one function.

One domain is enough because the three questions below only have answers at that level. Choose the function you already own or already understand well enough to describe its week without asking anyone.

The Three Scoping Questions

Then answer three questions:

1. What does this function produce?

Outputs, deliverables, decisions, reports.

Start here because it is the question a job description opens with. If a function's outputs are hard to list, that is worth knowing before any agent is designed, not after.

2. What tasks repeat most often?

Daily, weekly, per transaction, anything on a cycle.

Repetition is what makes work designable. A task that runs on a cycle has a shape you can capture and hand to a digital worker. A task that happens once, differently, does not.

3. Where do things break down or slow down?

Bottlenecks, delays, handoff failures, information gaps.

This is the question that tells you where to start rather than what is possible. The places work already stalls are the places a new worker changes something you can feel.

Your answers to these three questions become your agent design brief. Everything else follows. The roles you define in the next module, the org chart you draw, and the tracking you put around it all trace back to what you write down here.

Example: Contingent Workforce Program

Take a workforce program function and break it into its actual responsibilities.

Responsibility	What it covers
Requisition Intake	Capture, classify, and route incoming req requests
Compliance Monitoring	Track co-employment risk, tenure limits, classification flags
Vendor Intelligence	Benchmark rates, track fill performance, flag outliers
Worker Onboarding	Confirm starts, send instructions, track access completion
Reporting and Analytics	Headcount, spend, cycle time, compliance status
Stakeholder Communication	Updates, escalations, policy Q&A

Six responsibilities. Each one is a potential agent role, or at least a defined input to one.

Notice what this list is and what it is not. It is not a list of tools, and it does not mention AI once. It is what the function is responsible for, written the way you would write it for a team of people. That is the output of scoping: a function decomposed into responsibilities specific enough that someone could own each line.

Notice also that the six lines are not equal. Some are heavily repeatable and run on a cycle. Some concentrate at a handoff point. Some carry risk that a person needs to sign off on. Those differences are exactly what step 2 sorts out, and you can only see them once the responsibilities are written down separately.

Run the same exercise on your own function. Name the function, answer the three questions, then list the responsibilities the way this example lists six. The result is one page, and it is the only input the next module needs.

Key takeaways

• Scope one business function, not the whole company, because the design questions only have answers at the level of a single domain
• The three scoping questions are what the function produces, which tasks repeat, and where work breaks down or slows
• Your answers become the agent design brief, and everything in the rest of this stage follows from it
• A scoped function decomposes into named responsibilities, and each responsibility is a potential agent role or a defined input to one

Next step

You have a function broken into responsibilities. Not every responsibility needs its own agent, so step 2 of 4 gives you the filters that decide. Continue with Map Responsibilities to Agent Roles.