The Open-Source Agentic Coding Stack

AI coding tools are moving beyond the simple pattern of prompt → generate code → review. The more interesting direction is agentic coding: giving models tools, roles, context, and the ability to delegate work and iterate until a larger task is complete.

Two open-source projects worth understanding in this space are OpenCode and Oh My Open Agent. They sit at different layers, but they fit together naturally.

OpenCode: the agent harness

OpenCode is an open-source coding agent environment built around the terminal. It gives an agent access to files, shell commands, code search, editing, language-server tooling, and external tools. It is the harness in which the agent operates.

You can give it a task and let it inspect the repository, modify files, run tests, read failures, and continue working.

OpenCode also supports the idea of multiple agents with different roles, permissions, prompts, and models. You could have one agent focused on planning, another on implementation, and another on review. The important point is that OpenCode provides the environment where these agents can act.

Oh My Open Agent: orchestration on top

Oh My Open Agent adds a more opinionated structure and divides work between specialized agents.

One agent might explore the repository, another might research documentation, another might focus on architecture, another might implement the changes, and another might review the result.

OpenCode provides the runtime. Oh My Open Agent provides the orchestration.

OpenCode gives agents access to the codebase and tools. Oh My Open Agent helps define how those agents cooperate.

From assistant to agentic loop

This becomes more interesting when the agents are placed inside a loop. Imagine asking:

Add authentication to this application.

An agentic workflow treats the request as a process that continues through investigation, implementation, and verification.

A planner first understands the task and identifies the areas that need investigation. An exploration agent inspects the repository. A research agent looks at the relevant framework or authentication documentation. The planner combines those findings into an implementation approach.

An implementation agent makes the changes and runs the tests. If something fails, the agent reads the failure and adjusts the implementation. A reviewer can inspect the diff and identify issues that the implementation agent missed.

The loop becomes:

Understand → Explore → Plan → Implement → Test → Review → Correct → Repeat

The feedback loop keeps the model acting, observing the result, and deciding what to do next. That is much closer to real software development.

Tests fail. The agent investigates why, changes the code, and runs the tests again. A reviewer finds a problem, the implementation is updated, and the cycle continues.

Different agents can use different models

Each task can use the model that fits it best. A strong reasoning model might handle architecture and planning. A faster model can explore the repository. Another may be better for implementation, while a separate model reviews the final changes.

AI-assisted development becomes a combination of agents, models, and tools chosen for the problem.

Why open source matters

Open source keeps the workflow inspectable and adaptable. You can change it and build your own system around it.

A small project might need only:

Planner → Implementer → Reviewer

A larger project might use:

Planner → Researcher → Backend → Frontend → Tester → Reviewer

More agents can easily create more complexity and noise. I separate responsibilities only when it improves the loop.

OpenCode gives those agents an environment in which to work. Oh My Open Agent gives you a structured way to organize how they work together.

Together, they form a configurable development system where multiple agents can explore, reason, implement, test, review, and iterate around the same problem.