PTENES
Skill · parallel × sequential × hybrid

Decide on the architecture before creating agents

A skill that chooses between sequential, parallel, and hybrid workflows before execution — fewer tokens, less rework, more consistency.

Comparison: misused parallelism vs. smart sequencing with parallel automation
What it is

An architecture step before complex work

Too many agents rereading the same context waste tokens; blind sequencing wastes time. The skill makes a deliberate decision — and only then executes.

🚪 Proportionality gate

First decision: does the task require splitting, multiple executors, or extensive context? If not, execute directly — no planning bureaucracy.

⚖️ Decision matrix

Scored signals for sequential and parallel work, with an objective threshold: a difference ≥ 2 points decides; a tie or smaller difference → hybrid.

💸 Cheapest executor

Script for mechanical work, economical model for structured work, advanced model only for strategy and creation. Never an agent waiting for a render.

How it works

From request to plan — before the first subagent

The workflow separates reasoning from execution: it centralizes decisions, records the context once, automates the mechanical work, and parallelizes only what is truly independent.

Request→ Proportionality gate→ Break down→ Decision matrix→ Compact plan→ Execution→ Central review
1

Sequential

Dependent tasks or tasks with lots of shared context. What you learn at one step informs the next.

2

Parallel

Independent tasks, frozen inputs, little context per task. Renders and conversions become parallel scripts.

3

Hybrid

Default for large projects: centralized planning, a single specification, independent parallel execution, central review.

Prerequisites

What you need

The skill is a package of Markdown files — it works with any agent that supports skills. The test script uses the Claude Code CLI.

One agent with skills

Claude Code, ChatGPT (ZIP upload), or Codex. The core is universal; the platform mappings are in references/.

# check the CLI (for Claude Code)
claude --version

Git

To clone the repository with the skill, guide, and test script.

git clone https://github.com/inematds/agenteexecuta

Bash (optional)

Only to run the baseline × with skill behavioral test.

bash --version
User guide · step by step

Install and use the skill

From cloning to behavioral validation, with real commands.

1

Clone the repository

The skill lives in the folder arquiteto-de-execucao/, with SKILL.md, references, and a test script.

git clone https://github.com/inematds/agenteexecuta
cd agenteexecuta
2

Install in Claude Code

Copy the skill folder to the user's skills directory. It will then be triggered automatically before work involving subagents or batches.

cp -r arquiteto-de-execucao ~/.claude/skills/  # available in the next session
3

Or install in ChatGPT / Codex

Use the ready-made zip — it includes the agents/openai.yaml with the interface configuration for the OpenAI ecosystem.

# upload this file when creating the skill/GPT:
arquiteto-de-execucao-v2.zip
4

Use it for a large project

Ask for a task with multiple deliverables. The skill produces a compact plan BEFORE creating any subagents — strategy, what is sequential/parallel, executors, limits, and the main risk.

# example request that activates the skill:
"Produza 15 vídeos curtos da série X usando agentes. O guia de estilo tem 40 páginas."
5

When in doubt, consult the matrix

Scored signals and an objective threshold, with worked examples (15 videos, market research, migration, 500 files).

cat arquiteto-de-execucao/references/decision-matrix.md
6

Validate the behavior (baseline × with skill)

The script runs the 3 test scenarios in headless mode and saves the responses for manual review against the criteria for references/test-scenarios.md.

./arquiteto-de-execucao/scripts/test-skill.sh              # smoke test: scenario 1, 1 run
./arquiteto-de-execucao/scripts/test-skill.sh all both 5   # full test suite
Examples

The principle in numbers — and the plan the skill produces

The savings don't come from "sequential is always better": they come from amortizing the cost of shared context.

💰 Cost of repeated context

# 3 agents rereading the same material:
3 × (50k contexto + 20k execução) = 210k tokens

# 1 executor reusing the context:
50k + 20k + 20k + 20k = 110k tokens

📋 Compact plan (skill output)

Estratégia: híbrida.
Sequencial: planejamento, spec e revisão final.
Paralelo: tarefas independentes e mecânicas.
Executores: avançado p/ decisões; econômico
  p/ checklist; scripts p/ render.
Contexto: PROJECT-SPEC.md + CHECKLIST.md.
Limites: 3 subagentes, 2 tentativas,
  retrabalho só dos reprovados.
Roadmap

Skill evolution

From the monolithic version to a lean skill with behavioral validation.

v1
Original skillComplete methodology in a lengthy SKILL.md — good content, but bloated, an overly broad description, and no "when not to use" guidance.
v2
Current version — control panelProportionality gate, bilingual description focused on triggers, concise body (~400 words), matrix with an objective threshold, platform references (Claude Code, ChatGPT/Codex), and baseline × skill test script.
v3
Next stepsFull validation suite (5+ runs per scenario), veto conditions in the matrix (an unstable dependency rules out parallelism, regardless of the total score), and adjust the messaging based on the actual measured gain over the baseline.