# Analyze Agent Execution Engines

Agent frameworks hide concurrency, topology, events, and hooks across many files. This skill guides Claude, Codex, or Claude Code through a structured execution-engine review.

## Install

```bash
npx skillstore add dowwie/execution-engine-analysis
```

## Metadata

- Status: approved
- Slug: dowwie-execution-engine-analysis
- Skillstore revision: r1
- Version status: missing
- Tree hash: 213fea7afbd9f3f2a1ed1337fab3ff36d39b789d327552e90858401b766fc5d4
- Author: Dowwie
- GitHub username: Dowwie
- License: MIT
- Repository: https://github.com/Dowwie/agent\_framework\_study/tree/main/.claude/skills/execution-engine-analysis
- Ref: 72d5025b022c77f7a51bdf5c1637c689c80e89d1
- Supported tools: Claude, Codex, Claude Code
- Audit status: complete
- Agent install advisory: allowed
- Manual install advisory: allowed
- Artifact signature: available
- Audit attestation: unavailable
- Human verification: not\_verified
- Risk factors: external\_commands
- Quality score: 78
- Quality tier: bronze
- Public page: https://skillstore.pages.dev/skills/dowwie-execution-engine-analysis
- Manifest: https://skillstore.pages.dev/api/skills/dowwie-execution-engine-analysis/manifest

## Capabilities

- Classifies execution models as native async, sync-with-wrappers, or hybrid.
- Identifies topology patterns such as DAG, finite state machine, or linear chain.
- Catalogs callbacks, event listeners, emitters, and streaming generators.
- Maps observability hook points before and after LLM, tool, step, and error handling.
- Produces a markdown report covering concurrency, topology, events, hooks, and scalability.

## Use Cases

- Review a New Agent Framework: Map how a framework schedules work, handles async calls, and exposes hooks before adoption.
- Document Runtime Architecture: Create a consistent execution report for maintainers, contributors, and technical documentation.
- Compare Scaling Tradeoffs: Compare concurrency, event flow, and observability across frameworks before platform integration.

## Prompt Templates

### Classify a Framework

```
Use this skill to analyze the provided agent framework. Classify its concurrency model, execution topology, event architecture, observability hooks, and scalability limits.
```

### Map Events and Hooks

```
Use this skill to catalog all callback, listener, emitter, streaming, and error hooks. Note where hooks can observe, modify, or redirect execution.
```

### Compare Two Execution Engines

```
Use this skill to compare these two agent frameworks. Highlight differences in async support, graph or state models, event registration, streaming, and operational scalability.
```

### Audit Scalability Tradeoffs

```
Use this skill to assess the execution engine for production scaling. Identify blocking paths, concurrency boundaries, resource limits, backpressure points, and observability gaps.
```

## Limitations

- Requires source files or repository context to inspect execution behavior.
- Does not run benchmarks or measure live performance.
- Does not replace a full security review of framework execution.
- May miss dynamic behavior hidden behind reflection, plugins, or generated code.

## Best Practices

- Provide execution entry points and core orchestration files.
- Ask for evidence with file and function references for each classification.
- Review async behavior, topology, events, hooks, and scalability together.

## Anti Patterns

- Do not classify a framework from README claims alone.
- Do not ignore sync wrappers around async internals.
- Do not treat every callback system as full observability.

## Security Audit

- Audited at: 2026-07-06T12:11:26.007\+00:00
- Summary: All static findings were adjudicated as false positives. The flagged locations are markdown code fences, inline code examples, or analysis headings in SKILL.md, and no prompt injection or malicious intent was found.

## Stats

- Views: 229
- Downloads: 8
- Favorites: 1
- Popularity score: 0