Agentic Replica | HAP Analysis

What You're Trying to Do

Your goal is to document an existing human role exactly as it operates today. Think of it like creating a detailed photograph of how someone actually does their job, not how they're supposed to do it according to the job description.

You're creating a structured inventory of everything the person does: what triggers their work, what information they need, how they make decisions, what tools they use, and what they produce. This becomes the foundation for designing an AI agent that can handle some or all of these responsibilities.

Key principle: Don't propose changes or improvements yet. Your job right now is to capture the current state objectively. You'll redesign later during Agentic Reengineering.

The Four-Step Process

For each role you analyze, you'll work through four stages. Each builds on the previous one to create a complete picture of the role.

1

Define the Role

Scope & context

2

Inventory Skills

List all capabilities

3

Document Each Skill

Triggers, inputs, process, outputs

4

Identify Patterns

Escalations, judgment, tools

View Templates & Worked Example

1
Define the Role

Start by establishing the boundaries of what you're analyzing. You need to understand where this role sits in the organization and who it interacts with.

What to capture:

Role basics: The official title, which department they're in, and who they report to. This establishes organizational context.
Upstream dependencies: Who or what provides inputs to this role? This could be other people, systems, or external sources. For example, a financial analyst depends on accounting to close the books before they can do variance analysis.
Downstream consumers: Who receives what this role produces? Understanding the consumers helps you understand what "success" looks like for this role.
Primary systems: What software and tools does this person use every day? This becomes critical later when you're designing what an agent would need access to.

How to gather this information:

Review org charts and job descriptions from HR. These give you the official structure, even if reality differs.
Check system access logs with IT. What applications are they actually logging into? This reveals tools that might not be on the official list.
Map communication flows: who emails this person frequently, and who do they reach out to? Email patterns reveal the true working relationships.

2
Inventory All Skills

Before going deep on any single skill, step back and list all the distinct capabilities this person performs. A "skill" is a discrete unit of work that has its own trigger, process, and output.

For each skill, note:

Frequency: How often does this happen? Daily, weekly, monthly, or only when triggered by specific events?
Time spent: Roughly what percentage of their time goes to this skill? This helps prioritize which skills to document most thoroughly.
Judgment required: Is this mostly mechanical (follow the steps), or does it require significant thinking and decision-making? Low-judgment skills are often the best candidates for automation.

How to identify skills:

Review a week of their calendar: What types of meetings do they attend? Each recurring meeting type often represents a skill being exercised.
Analyze their email folders and labels: How do they categorize their work? Each category often maps to a distinct skill.
Look at their deliverables: What distinct types of outputs do they produce? Work backwards from outputs to understand the skills that create them.
Check ticketing or task systems: What categories of work items are assigned to them? Each category usually represents a different skill.

Calibration tip: Most white-collar roles have between 5 and 15 distinct skills. If you've identified fewer than 5, you're probably grouping too broadly and missing important distinctions. If you have more than 15, you may be splitting too finely and capturing variations of the same skill rather than truly different capabilities.

3
Document Each Skill in Detail

This is where the real work happens. For each skill in your inventory, you need to understand and document six key dimensions.

Triggers: What Causes This Work to Start?

Every skill is activated by something. It might be a scheduled event (the first Monday of each month), a message (an email from a customer), or a system event (a threshold being crossed in a dashboard).

How to find this: Review their email inbox for patterns. What types of messages initiate work? Check their calendar for recurring triggers. Look at their ticketing system for request types that come in.

Inputs: What Information and Resources Are Needed?

Once triggered, what does this person need to do the work? This includes data from systems, documents from colleagues, verbal context from conversations, and reference materials.

How to find this: Analyze file access logs to see what documents they open when doing this work. Review their sent email folder to see what they request from others. Check database query logs if available.

Process: How Is the Work Actually Done?

Document the step-by-step actions this person takes. Be specific about what tools they use at each step and roughly how long each step takes. Don't just describe the happy path, note the variations that happen in practice.

How to find this: Examine their work artifacts (spreadsheets, documents) to reverse-engineer the steps. Look at file version history to see the sequence of changes. A brief shadow session of 30-60 minutes can fill gaps.

Decision Points: Where Does Judgment Come In?

This is often the most valuable part to document. Where does the person have to think rather than just follow steps? What factors do they consider? What rules of thumb have they developed over time? This tacit knowledge is exactly what you need to capture for agent design.

How to find this: Ask "when do you have to think about this versus just doing it?" Look for conditional logic in their spreadsheets and documents. Review escalation patterns to see what triggered them to ask for help.

Outputs: What Does This Skill Produce?

What are the deliverables? Who receives them? What format are they in? What's the expected turnaround time? Understanding outputs helps you understand what "done" looks like.

How to find this: Review sent emails to see what they send and to whom. Check shared folders to see what they publish. Ask downstream consumers directly: "What do you receive from this person?"

Escalation: When Does This Need Human Intervention?

Even the most capable person sometimes needs to escalate. What conditions trigger that? Who do they escalate to? How often does it happen? This directly informs what guardrails and human oversight an agent would need.

How to find this: Look at their messages to their manager or more senior colleagues. What were they asking about? Review any exception logs or incident reports.

See the detailed skill template

4
Identify Cross-Cutting Patterns

After documenting all the individual skills, step back and look at the role as a whole. What patterns emerge across multiple skills? These patterns are essential for designing a coherent agent rather than a collection of disconnected capabilities.

Look for:

Common tools: Which systems are used across multiple skills? These become the core integrations an agent would need.
Escalation patterns: Are there common types of situations that always require human judgment? These inform the boundaries of what an agent should attempt autonomously.
Skill dependencies: Which skills feed into others? Understanding these chains helps you design agents that can handle workflows, not just isolated tasks.
Domain knowledge: What does this person need to know that isn't written down anywhere? This tacit knowledge must either be documented for an agent or flagged as a reason for human involvement.
Observed guardrails: What does this person never do? What do they always check before acting? These become the safety constraints for any agent taking over these responsibilities.

Automation candidates: Pay special attention to skills that are high frequency but low judgment. These are often the best candidates for full automation. Conversely, skills that are low frequency but require expert judgment are usually best left to humans.

From Replica to Agent Story

Your completed Agentic Replica provides the raw material for creating Agent Stories. The mapping is direct: triggers become agent triggers, skills become agent skills, tools become agent tools, escalation patterns become human oversight rules, and observed guardrails become agent guardrails.

Agentic Replica		Agent Story
Role title + scope		As [Agent Role]
Skill triggers		Trigger block
Skills inventory		Skills array
Tools used		Tools array
Escalation patterns		Human role + escalates_when
Quality indicators		Success criteria
Observed guardrails		Guardrails array
Decision points		Autonomy level determination

Key insight: One human role often maps to multiple Agent Stories. A skill with low judgment required might become a fully autonomous agent, while high-judgment skills might become supervised or collaborative agents with significant human oversight.

Agent Story Light Agent Story Full

Best Practices for Data Collection

How you gather information matters as much as what you gather. Here's guidance on doing this well.

What works well

Start with digital artifacts (emails, files, logs) before conducting interviews. Let the data guide your questions.
Ask "show me" not "tell me" when possible. Watching someone do the work reveals details they'd never think to mention.
Document what you observe, not what's "supposed to" happen. The gap between policy and practice is often where the interesting insights live.
Capture exceptions and edge cases carefully. They reveal where judgment is really being exercised.
Note time estimates even if rough. They help prioritize automation opportunities.

Common mistakes to avoid

Suggesting improvements while documenting. Save your optimization ideas for Agentic Reengineering. Right now you're just observing.
Relying solely on self-reported information. People often don't accurately describe their own work. Verify with data.
Skipping the "boring" routine tasks. These are often the best automation candidates and deserve thorough documentation.
Treating job descriptions as accurate. They're usually outdated. The real job has evolved.
Invasive monitoring without consent. Be transparent about what you're observing and why. Trust matters.

Ready to start documenting?

Get the copy-paste templates and see a complete worked example showing how all the pieces fit together for a real role.