# How we build and operate with AI agents day-to-day.

> Choose tasks, set limits, check results, and learn from day-to-day work with AI agents.

Source: https://helmframework.com/practitioners
Updated: 2026-09-17
License: https://creativecommons.org/licenses/by/4.0/

Practitioner Guide

[HELM 1.0.1](https://helmframework.com/changelog) · Updated 2026-09-17

For day-to-day agent-assisted work, start with the [operating loop](https://helmframework.com/practitioners#the-operating-loop). If you are designing an agent workflow or product, the architecture patterns below help you compare options. Choose the detail relevant to your task.

## Agent Architecture Patterns

### Agent Anatomy

These five parts are a simple way to understand an agent. Products combine them differently; check which parts your task actually needs.

These five parts help explain how an agent works.

| Component | What It Does | Example |
| --- | --- | --- |
| **Model** | A language model (LLM) generates outputs and may choose which tools to call. | Drafting an answer or selecting a tool |
| **Tools** | External functions, APIs, or systems the agent can invoke. | Database queries, web search, code execution, file I/O |
| **Instructions** | Explicit guidelines, scope constraints, and behavioral rules. | System prompts, AGENTS.md, rules files, policy documents |
| **Memory** | Information retained across interactions, with access and retention limits. | Conversation history, task state, saved project context |
| **Retrieval** | Looks up information the task needs. | Document search, a knowledge base, project files |

Products combine these parts differently. Check which information and tools your agent actually uses.

### Workflows vs. Agents

A workflow follows steps you define. An agent chooses steps as it goes. Compare the quality, cost, and time needed for your task before choosing.

Anthropic offers a useful distinction between workflows and agents:

| Dimension | Workflows | Agents |
| --- | --- | --- |
| **Control** | Follows steps defined in advance | Chooses steps as the task proceeds |
| **Predictability** | The path is defined; results can still vary | Both the path and results can vary |
| **Flexibility** | Limited to the paths you define | Can choose among permitted actions |
| **Best for** | Well-defined, repeatable tasks | Open-ended problems with unpredictable steps |
| **Cost/latency** | Measure calls and time for the workflow | Set limits and measure time and cost |
| **Error handling** | Defined checks and recovery steps | Feedback, stopping conditions and escalation |

**Use a workflow when you can define the steps in advance. Consider an agent when the next step depends on what it finds.** In either case, agree how to check the result and when to stop.

### Tool Types

Reading data can still expose private information. Consider what each tool can see or change, who could be affected, and whether a mistake can be undone.

These three tool categories help you plan access and checks:

**Data tools** retrieve context and information. They can expose sensitive data even when they cannot change it. Examples: Query databases, read documents, search the web, pull CRM records.

**Action tools** change something in a system. Consider who is affected and how a mistake could be corrected. Examples: Send emails, update records, create tickets, issue refunds, deploy code.

**Orchestration tools** let an agent ask another agent to carry out part of the work. Examples: A “research agent” callable by a “manager agent,” a specialist agent invoked by a triage agent.

Assess each tool’s risk by what it can access, who could be affected, and whether a mistake can be undone. Use that assessment to choose the limits and checks it needs.

### Composition Patterns

These patterns are starting points. Their complexity depends on your task, so try a simple option and check the result before adding more.

These eight patterns are options to compare. Start with the simplest approach that meets the task’s needs; additional agents or steps should address a problem you have observed.

Pattern 1

#### Prompt Chaining

Split a task into a fixed sequence of steps. Each model call uses the previous result, with checks between steps.

##### When to consider it

The task has clear steps. Compare whether the extra calls improve quality enough to justify their time and cost.

##### Example

Generate marketing copy, then translate it. Write an outline, validate it against criteria, then write the full document.

Pattern 2

#### Routing

Classify the input and direct it to a specialized handler. Each route has its own optimized prompt and tools.

##### When to consider it

Distinct categories that are better handled separately. Classification can be done accurately.

##### Example

Customer service — route general questions, refund requests, and technical support to different downstream processes.

Pattern 3

#### Parallelization

Run subtasks simultaneously and aggregate results. Two variants: Sectioning (independent subtasks) and Voting (same task, multiple perspectives).

##### When to consider it

Subtasks are independent (sectioning) or you need multiple perspectives (voting).

##### Example

One model processes the user query while another screens for safety. Multiple prompts review code for vulnerabilities; flag if any finds a problem.

Pattern 4

#### Evaluator-Optimizer

One model generates a response and another reviews it. Repeat within agreed limits, and stop for human review when needed.

##### When to consider it

Clear evaluation criteria exist, and iterative refinement provides measurable improvement.

##### Example

Literary translation with a critic loop. Complex search tasks requiring multiple rounds of analysis.

Pattern 5

#### Single Agent Loop

One model uses tools and feedback until it finishes, reaches a limit or needs help.

##### When to consider it

Dynamic decision-making about which tools to call and in what order, but complexity does not warrant splitting across multiple agents.

##### Example

A coding agent that reads files, writes code, runs tests, and iterates until tests pass.

Pattern 6

#### Orchestrator-Workers

A central LLM dynamically breaks down tasks, delegates to worker LLMs, and synthesizes results. Unlike parallelization, subtasks are not pre-defined.

##### When to consider it

Complex tasks where you cannot predict the number or nature of subtasks in advance.

##### Example

A coding product that determines which files need changing and dispatches changes to workers.

Pattern 7

#### Manager (Agents-as-Tools)

A central "manager" agent calls specialized agents as tools. The manager retains control and context, synthesizing outputs into a unified interaction.

##### When to consider it

You want a single agent maintaining central control and user interaction while delegating specialized work.

##### Example

A manager agent that calls translator agents for Spanish, French, and Italian, synthesizing all results for the user.

Pattern 8

#### Decentralized Handoff

Agents operate as peers, handing off full execution control to one another based on specialization. No central coordinator.

##### When to consider it

You don't need central control or synthesis. Each specialized agent can fully take over the interaction.

##### Example

A triage agent hands off entirely to technical support, sales, or order management. The receiving agent owns the conversation.

#### Pattern Selection Guide

Use the problem you have observed to choose an option. Compare it with the simplest approach that could meet the task’s needs.

Start Single LLM call with good prompting

Output quality insufficient

Consider Prompt Chaining or Evaluator-Optimizer

Start Prompt Chaining

Task decomposition isn't fixed

Consider Single Agent Loop

Start Single Agent Loop

Tool selection or overlapping tasks cause repeated errors

Consider Manager or Orchestrator-Workers

Start Single Agent Loop

Distinct categories with different handling

Consider Routing + specialized agents

Start Manager pattern

Central agent bottlenecks; specialists need full autonomy

Consider Decentralized Handoff

**Keep it simple:** Add another agent only when it addresses a problem the simpler approach cannot handle well.

* * *

## The Guardrail Stack

Use the five layers as a starting checklist. Written instructions alone do not restrict access, and passing automated checks does not guarantee the work is ready.

The five layers help you review scope, quality, policy, human decisions and shared oversight. Consider each layer before expanding the work. The controls you need depend on the task and its consequences. See [Principle 4: Guardrails Are Non-Negotiable](https://helmframework.com/foundation#principle-4-guardrails-are-non-negotiable).

5

Governance (fleet-level controls)

Fleet-level controls for managing agents at organizational scale.

| Element | Description |
| --- | --- |
| Registry | Single source of truth tracking all agents, their capabilities, owners, and status |
| Access control | Role-based permissions determining which agents can access which systems and data |
| Observability | Unified monitoring across all agents — execution traces, cost tracking, error rates, latency |
| Interoperability | Standards for agents to work across platforms and teams (e.g., Model Context Protocol) |
| Audit trail | Record relevant actions, approvals and outcomes, with appropriate access and retention |
| Cost budgeting | Per-agent and per-team token/compute budgets with alerts and hard limits |

4

Human Decision (judgment and accountability)

Ensure humans retain authority over decisions that agents must not make autonomously.

| Element | Description |
| --- | --- |
| Architecture | System design, technology choices, data model changes |
| Risk acceptance | Shipping known tradeoffs, accepting technical debt |
| Release timing | When code goes to production |
| Incident response | Rollback decisions, postmortem actions |
| Security-critical changes | Authentication, authorization, encryption |
| Cost commitments | Actions with financial impact above defined thresholds |

3

Policy (safety and compliance)

Apply the privacy, security and organizational controls the work needs.

| Element | Description | Example |
| --- | --- | --- |
| No secret exposure | Automated secret scanning in pre-commit and CI | Credentials leaking into repositories |
| PII filtering | Limit access to personal information and check outputs for unintended disclosure | Privacy violations in generated content |
| Safety classification | Treat untrusted input carefully; detection can help but may miss attempts to redirect an agent | System exploitation |
| Relevance classification | Flag off-topic or out-of-scope agent behavior | Scope drift and waste |
| Moderation | Content safety checks on agent outputs | Harmful or inappropriate generated content |
| Dependency policy | Block unsafe dependency upgrades or additions | Supply chain attacks |
| Branch policy | No direct pushes to main/protected branches | Unreviewed code reaching production |

2

Quality (code and output correctness)

Use automated checks and human review to find problems before the work is used.

| Element | Description |
| --- | --- |
| Formatting & linting | Enforce style consistency (Black, ESLint, Prettier, etc.) |
| Type checking | Static type verification (mypy, TypeScript strict mode) |
| Unit & integration tests | Run relevant tests and add meaningful checks for the change |
| Static analysis | Security scanning, dependency vulnerability checks |
| Coverage thresholds | Review coverage alongside the importance of the cases being tested |
| Design system compliance | Agent-generated UI follows the component library and design tokens |
| Accessibility standards | Automated and manual checks against the relevant accessibility requirements |

1

Scope (task limits and access)

Define what the agent may do and enforce the access and execution limits needed for the task.

| Element | Description | Example |
| --- | --- | --- |
| Target | Name the files or systems the agent may use and restrict its permissions accordingly | src/api/users/, payments\_table |
| Non-goals | What the agent must NOT change | "Do not modify authentication logic" |
| Acceptance criteria | Concrete definition of "done" | "All tests pass, endpoint returns 200 with valid payload" |
| Allowed dependencies | What the agent may import or call | "No new external packages without approval" |
| Max iterations | Upper bound on agent execution cycles | 20 tool calls, 10 minutes wall time |

* * *

## The Operating Loop

### The Plan-Execute-Verify-Ship-Learn Cycle

Try the loop on one task, then discuss what helped and what to change. It is a suggested working practice, not a promise of faster delivery.

Use this loop in an existing task or review. Agree the work, carry it out, check it, decide whether to use it and learn from the result. In software work, automated checks may run in continuous integration (CI) before a pull request (PR) is merged.

Plan Product + Engineering

Agree the task, its limits and how the result will be checked.

*   Product defines: Goal, acceptance criteria, UX requirements
*   Engineering defines: Scope, non-goals, risk level, constraints, verification method
*   Record who reviews the result, who decides whether it is ready and when to stop
*   Match tool access and execution limits to the plan; instructions alone do not enforce them

Execute Agents (monitored)

Agents carry out the agreed task with configured access and execution limits.

*   Generate code, tests, documentation, or refactors
*   Call tools as needed (data retrieval, API interactions, code execution)
*   Iterate within the defined scope (run tests, fix failures, retry)
*   Operate within configured iteration limits
*   People monitor progress and intervene when the task reaches a limit or needs a decision

Verify Automated + Human

Check the work with appropriate automated checks and human review.

*   Automated: CI pipeline, static analysis, security scanning, coverage thresholds, policy checks
*   Human — Engineering: code review, architecture alignment, edge case consideration
*   Human — Product: acceptance review, UX review, copy review, accessibility check
*   Review depth scales with risk level

Ship Human decision

Decide whether to release the work and confirm how to recover from a problem.

*   Audit trail: what was generated, by which agent, reviewed by whom
*   Recovery: agree a rollback or recovery procedure, including how to handle irreversible changes
*   Post-merge monitoring: watch for anomalies in error rates and latency
*   Diff review: ensure merged code matches what was reviewed

Learn Whole team

Use what happened to improve the next task, check or handoff.

*   Update instructions when a correction reveals a useful general lesson
*   Refine task templates: tighten plans that were ambiguous
*   Update evaluation criteria: add checks the verify step missed
*   Share useful examples and changes with the team
*   Remove instructions or steps that no longer help

### Task Classification Matrix

Use the examples to start a discussion. Before delegating, check the agent’s access, the possible consequences, and what your checks might miss.

Discuss two questions: **boundedness** means how clearly the task is defined; **risk** means what could happen if it goes wrong. The examples below are starting points. Access, data sensitivity and the limits of your checks can change the classification.

Boundedness

Low Risk

Medium Risk

High Risk

Well-bounded

Semi-bounded

Open-ended

Risk

Agent-driven Well-bounded / Low Risk

Automated verification. Sampling review.

##### Engineering

*   Local API prototypes using synthetic data
*   Code formatting, linting, and style fixes
*   Documentation and changelog generation

##### Product

*   Copy and microcopy generation within brand guidelines
*   Test case generation from acceptance criteria
*   Competitive analysis summaries from public data

Agent-driven Well-bounded / Medium Risk

Automated + human verification.

##### Engineering

*   Frontend component generation and cleanup
*   Test generation for existing business logic
*   Migration scripts tried on disposable test data

##### Product

*   PRD drafts from user research notes
*   User story decomposition from high-level requirements
*   Design-to-code translation using design system components

Agent-assisted Well-bounded / High Risk

Human-led with agent drafts. Full review.

##### Engineering

*   Security-adjacent feature implementation
*   Payment flow modifications
*   Data model changes with migration

##### Product

*   User-facing copy with legal/compliance implications
*   Onboarding flow changes affecting activation metrics

Agent-driven Semi-bounded / Low Risk

With human plan review.

##### Engineering

*   Exploratory refactors with clear goals
*   Performance optimization within defined bounds

##### Product

*   Feature spec elaboration from brief outline
*   Design exploration within existing system

Agent-assisted Semi-bounded / Medium Risk

Human review mandatory.

##### Engineering

*   Cross-service integration work
*   Complex business logic implementation

##### Product

*   Multi-step workflow redesign
*   New feature prototyping within constraints

Human-led Semi-bounded / High Risk

Agent may draft, human designs and reviews.

##### Engineering

*   Auth system modifications
*   Infrastructure security hardening

##### Product

*   Pricing model implementation
*   Compliance-critical workflow changes

Human-led Open-ended / Low Risk

With agent support for research/exploration.

##### Engineering

*   Technology evaluation and prototyping
*   Architecture documentation drafts

##### Product

*   Market research synthesis
*   Competitive landscape analysis

Human-led Open-ended / Medium Risk

Agent provides options, human decides.

##### Engineering

*   Novel architecture decisions
*   Performance-sensitive distributed systems

##### Product

*   Product strategy options analysis
*   User research synthesis and insight generation

Human only Open-ended / High Risk

People own these decisions. Scope any agent research or drafting as a separate task with appropriate access and review.

##### Engineering

*   Approving changes during a production incident
*   Accepting security risk after an investigation

##### Product

*   Final product strategy and roadmap decisions
*   Approving customer-facing claims and brand commitments
*   Approving pricing and packaging commitments

### The Human-Agent Boundary

Ask: **“If the agent gets this wrong, what happens, and how will we notice?”**

*   For a bounded, reversible task, an agent may execute within agreed permissions and checks.
*   If a mistake could affect a customer, agree the human review and approval needed before use.
*   For security-sensitive or production changes, a person owns the decision and explicitly limits any agent assistance.
*   If the consequences are unclear, investigate them before delegating.

A passing check only covers what it tests. Revisit the boundary when the task, tools or evidence change; you may need more human involvement as well as less.

The [role guides](https://helmframework.com/roles) discuss responsibilities and learning. Use the [Role skills explorer](https://helmframework.com/roles/competency-map) to compare the skills in those guides, or choose a [shared-skill practice guide](https://helmframework.com/competencies) for your role.

* * *

## Maturity Model

Use the levels to discuss working practices, not to score people. More independent agent work does not automatically mean better work, and one person’s level is not a tested measure of the whole team.

These five levels describe patterns of agent use, drawing on Eledath’s “Levels of Agentic Engineering.” Use them to discuss the checks, skills and support a workflow needs. They do not establish a team’s performance or require every team to move to a higher number.

> The [Leadership Guide](https://helmframework.com/leadership#maturity-model) has a short version of these levels for team discussions.

Level 1

#### Assisted

AI provides suggestions that developers accept, modify, or reject. The developer drives all decisions and execution.

"We use Copilot for suggestions"

##### Dimensions

Capabilities Tab completion, inline suggestions, single-turn Q&A, code explanation

Tools GitHub Copilot, ChatGPT, basic AI-assisted IDE features

Human role Full control. AI is a passive tool.

Agent autonomy None. Every output requires explicit human action.

Product dimension PMs and designers use AI for ad-hoc tasks (drafting docs, brainstorming). No integration with engineering workflows.

Risk profile Depends on the task and data. Reviewing each suggestion can still miss errors.

##### Signs to discuss

*   Developers use AI for suggestions but control all execution
*   No structured prompting or context engineering
*   No shared rules or templates for AI usage
*   AI usage is individual, not team-standardized

Failure mode Accepting suggestions without checking or understanding them.

Level 2

#### Structured

AI operates within structured contexts. Teams use dedicated AI IDEs, maintain rules files, and follow defined prompting patterns.

"We have rules files and task templates"

##### Dimensions

Capabilities Multi-turn agent interactions, context-aware generation, file editing, multi-file changes

Tools Cursor, Claude Code, Windsurf, AI IDEs with agent mode

Human role Defines context, reviews output, makes all commit/merge decisions

Agent autonomy Executes within a single session under human supervision

Product dimension PMs use structured templates for acceptance criteria. Designers contribute design tokens as agent instructions.

Risk profile Human review helps, but risk still depends on access, consequences and what the review covers.

##### Signs to discuss

*   Team uses AI IDEs with structured context (rules files, project-level instructions)
*   Shared task templates exist for common operations
*   All AI-generated output goes through standard code review
*   Team has basic conventions for when and how to use AI tools

Failure mode Useful prompting and review practices are known by only a few people.

Level 3

#### Integrated

Agents use automated feedback during development. CI checks support human review of the result.

"Agents iterate on CI feedback; rules improve each cycle"

##### Dimensions

Capabilities Agent runs tests, interprets failures, iterates to fix. CI-as-verification. Automated evaluation.

Tools AI IDE + CI integration + automated eval suites + MCP integrations + shared skills libraries

Human role Defines plans and acceptance criteria. Reviews against criteria. Owns architecture and risk decisions.

Agent autonomy Executes multi-step tasks and self-corrects based on automated feedback.

Product dimension PM acceptance criteria feed directly into agent task plans. Design system compliance automated in CI.

Risk profile Automated checks can miss important cases. Human review remains necessary where consequences or uncertainty require it.

##### Signs to discuss

*   Agents iterate based on CI/test feedback without human intervention in the loop
*   Useful lessons from completed work inform instructions, templates and checks
*   Evaluation coverage is explicitly tracked and improving
*   Guardrail stack (all 5 layers) is operational
*   Team measures agentic adoption KPIs

Failure mode Silent quality drift if eval coverage is incomplete. Over-reliance on passing CI without understanding what's tested.

Level 4

#### Autonomous

Agents operate in the background, working on tasks asynchronously. Humans define tasks and review results.

"Agents raise PRs overnight that we review in the morning"

##### Dimensions

Capabilities Background agents. Overnight PRs. Multi-repository operations. Batch task processing. Parallel agent execution.

Tools Background agent runners (Claude Code background, Codex, custom pipelines). Git worktree isolation.

Human role Defines task batches. Reviews completed PRs. Approves merges. Monitors agent fleet health.

Agent autonomy High within bounded tasks. Agents work unsupervised for extended periods.

Product dimension Agents autonomously generate PRDs from user data; PMs review outputs. Design reviews shift to auditing at scale.

Risk profile Elevated. Unsupervised execution means errors may compound before detection.

##### Signs to discuss

*   Agents produce PRs asynchronously (not just in interactive sessions)
*   Human review happens after completion, not during execution
*   Cost tracking and budgeting is active per agent and per team
*   Execution records show relevant tool calls, outputs and failures for review
*   Incident response protocol exists for agent-caused failures

Failure mode Stale instructions produce unsuitable work, or uncapped runs exceed the budget.

Level 5

#### Orchestrated

Multiple agents coordinate in parallel, managed by orchestration systems.

"An orchestrator dispatches work across a fleet of agents"

##### Dimensions

Capabilities Multi-agent coordination. Agent fleet management. Cross-team agent sharing. Agent-to-agent communication.

Tools Custom orchestration platforms. Agent registries. Multi-agent frameworks. Internal skills marketplaces.

Human role Defines objectives and constraints at the system level. Manages the agent fleet. Reviews aggregate output.

Agent autonomy Very high. Orchestrator coordinates; individual agents execute specialized tasks. System-level decisions still human-owned.

Product dimension End-to-end workflows span from user research to shipped feature with agent execution at each stage.

Risk profile High. Emergent behavior from agent interactions. Coordination failures. Cost multiplication.

##### Signs to discuss

*   An orchestrator coordinates multiple agents working on related tasks
*   Agents are shared and reused across teams (internal skills marketplace)
*   Fleet-level observability tracks all agents, costs, and outcomes in one view
*   Governance framework (registry, access control, audit) is fully operational
*   The organization can articulate and enforce policies across the agent fleet

Failure mode Coordination failures between agents. Emergent behaviors not covered by individual agent guardrails.

Look at the actual workflow and handoffs. One person’s tool adoption is not a formula for team capability, and a well-controlled simple workflow may be the right choice.

* * *

## Further Reading

*   [_Building Effective Agents_](https://www.anthropic.com/engineering/building-effective-agents) — Anthropic
*   [_A Practical Guide to Building Agents_](https://openai.com/business/guides-and-resources/a-practical-guide-to-building-ai-agents) — OpenAI
*   [_AI Agents Whitepaper_](https://www.kaggle.com/whitepaper-agents) — Google
*   [_Cloud Adoption Framework_](https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/ai-agents/) — Microsoft
*   [_Agentic Engineering for Software Teams_](https://vibecoding.app/blog/agentic-engineering-for-software-teams) — vibecoding.app
*   [_The 8 Levels of Agentic Engineering_](https://www.bassimeledath.com/blog/levels-of-agentic-engineering) — Eledath
*   [_Top Strategic Technology Trends 2026_](https://www.gartner.com/en/articles/top-technology-trends-2026) — Gartner
*   [_Five Stages of Agentic Evolution_](https://www.gartner.com/en/articles/intelligent-agent-in-ai) — Gartner
