agentic-engineering

Implement a Plan-Act-Observe loop with structured output validation and provider-agnostic tool execution.

Updated Mar 2, 2022
One-click install
npx skills add https://github.com/ysuurme/azure_hello_world --skill agentic-engineering-ysuurme
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: agentic-engineering
Source: https://github.com/ysuurme/azure_hello_world/tree/main/.agents/skills/agentic-engineering
Command: npx skills add https://github.com/ysuurme/azure_hello_world --skill agentic-engineering-ysuurme

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps you design and implement autonomous AI agents that can plan, use tools, observe results, and iterate until they produce a validated structured output.

Core Features & Use Cases

  • Plan-Act-Observe loop architecture: Implements a recursive agent loop with tool selection, execution, and observation across multiple LLM calls.
  • Structured output enforcement: Ensures the final result parses into a specified Pydantic model, with correction-on-parse-failure instead of crashing.
  • Provider-agnostic tool execution: Centralizes tool execution in an isolation layer that never raises, returning errors as observations.
  • State persistence and observability: Saves an agent checkpoint after each iteration and emits OpenTelemetry spans per loop iteration.

Use case: Create an agentic workflow that takes a goal and tool definitions, performs multi-step research and validation using document search tools, and returns a strictly validated architecture artifact outline.

Quick Start

Use agentic-engineering when you need an iterative Claude tool-using agent that persists state, enforces structured outputs, and stops reliably at success, max-iterations, or terminal tool error.

Frequently Asked Questions about agentic-engineering

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I build an autonomous AI agent that loops safely with tool use?

An autonomous AI agent loop safely executes tools by centralizing execution in an isolation layer that never raises exceptions, returning errors as observations for the next iteration. This prevents crashes during multi-step tool execution.

How does structured output enforcement work when an LLM parse fails?

Structured output enforcement validates LLM responses against a specified Pydantic model and applies correction-on-parse-failure instead of crashing. This ensures the agent loop iterates until a strictly validated output is produced.

What is the best way to manage state and observability across multi-agent iterations?

State checkpointing and observability across multi-agent iterations are managed by saving an agent checkpoint after each loop iteration and emitting OpenTelemetry spans. This provides per-iteration tracing and reliable state persistence.

Why does my Claude agent loop crash or hang indefinitely during tool execution?

An agent loop crashes or hangs when tool execution raises unhandled exceptions or lacks max-iteration termination. Provider-agnostic tool execution with non-raising error handling and max-iteration limits stops the agent reliably at success or terminal error.

Can I use Pydantic for structured output validation in a multi-agent orchestration workflow?

Yes, you can use Pydantic for structured output validation in multi-agent orchestration by enforcing strict parsing of the final result. The agent applies correction-on-validation-failure to ensure the output matches the specified model.

What does agentic-engineering do for recursive Plan-Act-Observe loops?

Agentic-engineering designs recursive Plan-Act-Observe loops that call Claude repeatedly with tool selection, execution, and observation across multiple LLM calls. It implements context window management, state checkpointing, and structured output validation.