Plan and configure agent solutions
Agent Flows and Human Approval
CoreBuild deterministic agent flows with explicit inputs, outputs, connector actions, approvals, error paths, and operational monitoring.
Aligned to the AB-620 live Skills measured outline; visible page date April 21, 2026; product behavior verified September 19, 2026.
Why this matters
Agent flows turn a conversational decision into an operational change. Inputs, connector identity, approval gates, output contracts, and failure behavior determine whether that change is safe and diagnosable.
Must Know
- Create an agent flow: Define a flow trigger contract, deterministic actions, and outputs that the agent can invoke and interpret.
- Create a human-in-the-loop agent flow: Insert an approval or review step before a sensitive action and branch explicitly on approve, reject, timeout, and cancellation.
- Configure actions and connectors: Choose connector actions that match the required operation and configure their connection identity and data-policy boundary.
- Monitor agent flows: Use run history, statuses, durations, inputs, outputs, and connector errors to diagnose and trend flow execution.
- Add input and output parameters: Define minimal typed inputs and structured outputs with names and descriptions that form a stable agent-flow contract.
- Implement error handling in agent flows: Catch expected failures, return safe actionable status, use bounded retries for transient errors, and avoid duplicate side effects.
Compare and Distinguish
- An agent flow is a deterministic workflow exposed to an agent; a topic controls conversation logic and can call the flow.
- A human-in-the-loop step pauses for accountable review; a notification merely informs someone and does not provide an approval result.
- Inputs form the invocation contract; outputs return structured results that later orchestration or topic nodes can consume.
Scenario examples
- Scenario: A pilot succeeds but production users have different permissions. Think: trace identity and authorization through every source, tool, and delegated agent.
- Scenario: A component works in development but fails after deployment. Think: inspect solution dependencies, connections, environment configuration, and channel-specific behavior.
- Scenario: A response is fluent but the operational result is uncertain. Think: separate generation from retrieval, tool execution, telemetry, and verification.
Exam traps
- Returning no structured failure output, leaving the agent unable to explain a downstream error.
- Using the maker’s personal connection where a governed service identity or user connection is required.
- Retrying a non-idempotent operation without a duplicate-prevention design.
Key takeaways
- An agent flow needs a stable invocation contract, an explicit execution identity, observable runs, and a defined result for every approval or failure path.
- Make the identity, data, lifecycle, and failure boundaries explicit for create and monitor agent flows in copilot studio.
- Validate the behavior with representative evidence before broad deployment.
How it works
- Copilot Studio uses the configured descriptions, instructions, conversation state, and orchestration mode to select the relevant topic, knowledge, tool, flow, or connected agent.
- Runtime identity and environment configuration determine whether the selected capability can access its dependency and return a governed result.
Objects and administrative surfaces
- Copilot Studio Flows area and flow designer.
- Power Automate run history and connection references for execution diagnosis.
- Topic or tool configuration where a flow is made available to the agent.
When to use it
- Use this topic when the requirement maps to create and monitor agent flows in copilot studio.
- Prefer the narrowest supported surface that satisfies the required behavior and governance boundary.
Security and governance implications
- Apply least privilege to maker, runtime, connector, source, and deployment identities.
- Classify data and connectors, preserve audit evidence, and avoid exposing secrets or sensitive payloads in prompts and telemetry.
Troubleshooting signals
- Reproduce with the same version, channel, identity, inputs, and environment before changing configuration.
- Use activity traces, flow runs, tool errors, evaluation results, or telemetry to locate the failing layer.
More detail
- An agent flow exposes a deterministic workflow to the agent. Its trigger inputs and returned outputs form the contract that a topic or orchestration path must map correctly.
- Configure the connector operation, connection identity, and data-policy boundary independently from the conversational logic; a valid flow design can still fail when its connection is unauthorized.
- A human-in-the-loop step is a control point, not a notification. The flow must pause for a result and define what happens after approval, rejection, timeout, or cancellation.
- Use run history to separate trigger or parameter problems from connector failures and approval delays by inspecting status, duration, inputs, outputs, and errors.
- Keep parameters minimal and typed, and return structured success or failure information so the calling agent can branch or explain the outcome safely.
- Handle expected failures explicitly. Retry only appropriate transient failures within bounds, and protect operations with side effects from accidental duplicate execution.
Ready for the quiz?
- Which requirement determines the correct surface for create and monitor agent flows in copilot studio?
- Which identity performs the operation, and where is authorization enforced?
- What evidence distinguishes a safe successful result from a fluent but incomplete one?
Related objectives
- D1.2.S1 — Create an agent flow
- D1.2.S2 — Create a human-in-the-loop agent flow
- D1.2.S3 — Configure actions and connectors
- D1.2.S4 — Monitor agent flows
- D1.2.S5 — Add input and output parameters
- D1.2.S6 — Implement error handling in agent flows