Agentic Workflow

A multi-agent software-delivery pipeline for OpenCode.

What It Is

This is a configuration-only package — no application code. Everything lives in .opencode/ as agent definitions and skill files. OpenCode auto-discovers them on launch.

The key design principle: Core never writes code — it only thinks, routes, and verifies. This prevents self-execution, the most common AI agent failure mode.

Core Concepts

• Agentic Engineering — Using AI agents as software engineers that plan, execute, verify, and iterate. The shift from "autocomplete" (generate code in one shot) to "autonomous workflow" (agents that think before they act and check their own work).

• Agent — A self-directed unit with a defined role that can use tools, reads skills on demand, and produces structured output. In this project, each agent has a specific job: orchestrate, plan, implement, test, or review.

• Subagent — An agent invoked by another agent (the orchestrator) to handle a specific phase. Subagents are hidden from the user — you only interact with Core, which fans out work to subagents via the Task tool. This enforces the pipeline: you can't skip to Implement without going through Define and Plan first.

• Orchestration — The pattern where a non-coding coordinator (Core) routes work, checks gates, and ensures quality. Core never writes code — it only thinks, routes, and verifies. This prevents the most common AI failure: self-execution.

• Skills — Reusable instruction files that agents load on demand. Instead of dumping all context into the agent at once, each agent reads only the skills relevant to its current task. This is context engineering — keeping the working context lean and relevant.

• Gates — Pass/fail checkpoints between pipeline stages. A failed gate never advances forward — it loops back to the failing stage with specific feedback. This guarantees quality without relying on the agent to "remember" to verify.

• Thin Vertical Slices — Work is decomposed into small, independently testable units. Each slice delivers end-to-end behavior (not just a layer). This makes verification possible and parallel execution safe.

The Pipeline

User Request
     |
     v
 [Core: triage] -- trivial? --> @implement (direct)
     |
     v (non-trivial)
 @define --> @planner --> @implement --> @test --> @review
     |           |            |            |           |
     +-- gate ---+-- gate ----+-- gate ----+-- gate ---+
   failed gate -> loop back to failing stage (never forward)

Stages:

• Core — Orchestrator. Never writes code. Routes requests and checks gates.
• @define — Surfaces requirements through structured interview. Produces spec with acceptance criteria.
• @planner — Decomposes spec into thin, verifiable task slices.
• @implement — Implements one slice at a time. Verifies APIs against docs. Runs slices in parallel when safe.
• @test — Writes failing tests first, then verifies they pass. Browser testing for UI.
• @review — Simplifies code and optimizes only measured hot paths.

Feedback loops: Failed gates never advance forward. Core routes back to the failing stage with specific feedback.

Getting Started

1. Install OpenCode — see https://opencode.ai/docs/

2. Clone this repository:

   git clone https://github.com/nadimnesar/agentic-workflow.git
   cd agentic-workflow

3. Launch OpenCode and select the core agent:

   opencode

4. Describe your task to Core. It routes automatically through the pipeline.

Use With Any Project

To use this agentic workflow with any existing project:

1. Copy the .opencode folder and opencode.json into your project's root directory.

2. Navigate to your project and launch OpenCode.

OpenCode auto-discovers the agents and skills from the .opencode folder. No other setup is needed.

Usage

• Non-trivial features: Describe the goal to Core. It runs the full pipeline and returns a Delivery Summary.
• Trivial tasks: Core routes directly to implement (typo, rename, config toggle).
• Parallel execution: 3+ independent slices run concurrently.

Project Structure

agentic-workflow/
├── .opencode/
│   ├── agents/           # 6 agent definitions
│   │   ├── core.md       # orchestrator (primary)
│   │   ├── define.md     # requirements → spec
│   │   ├── planner.md    # spec → task slices
│   │   ├── implement.md  # implements slices
│   │   ├── test.md       # verifies slices
│   │   └── review.md     # simplifies + optimizes
│   └── skills/           # 17 skill files
├── opencode.json         # project config
├── .gitignore
└── LICENSE

License

MIT — see LICENSE.

Copyright © 2026 Nesar Ahmed.