Agentic links and notes

Orchestration ideas

Starting out

Agentic AI might allow us to completely reimagine our workflows, maybe for subsets of our tasks, or maybe for an entire project. However, we don't need to make a huge leap to a novel, unfamiliar, highly agentic process overnight - we would probably be correct in seeing that as risky (costs and quality). As an early step, however, my former colleague Dicky recommended introducing very simple agent-human loops into our existing workflows, as this will be a good learning experience, then we can take it from there. Examples:

• A simple bug-fixing loop with existing automated tests and human code review as guardrails.

• Assurance activities (exploratory test, code/design review, security analysis). N.B. early in workflow for fast feedback.

• Work on documentation and tickets (writing/neatening requirements and ACs). May also apply to delivery management artefacts.

Existing deterministic automation might not change much, for now

Workflow automation that deals with builds, deployments, regression testing and other quality checks might not need a huge rethink. These things are meant to be deterministic, either giving us reliable execution of repetitive operational tasks (like deployments) or guardrails and feedback loops (like tests), which may well be just as important, or even more so, with agentic development.

I suspect that, for many projects at 'normal' organisations, rather than completely reshaping the journey to prod, AI's biggest immediate impact on workflow automation area will be in catching up. Teams can quickly develop much better deterministic CI/CD pipelines and tests than before - the kinds that were already possible, but evidentally difficult to achieve. Anecdotally, good DevOps practices are often lacking outside of the most modern tech environments and catching up was always a big challenge, competing against other business priorities. There isn't really an excuse not to catch up rapidly now and I suspect the value will be significant.

Even if we adopt additional agentic workflows (e.g. monitoring --> bug ticket creation --> fix proposal) or supplement our core pipelines with extra beneficial agentic steps (e.g. code review, security/performance analysis), the basic structure and deterministic elements of CI/CD might remain familiar for a while.

Option: keep it simple - use the AI development tools as they come

It might be the case that AI development tools are increasingly becoming so good that we don't need to complicate things with much customisation.

The frontier labs are doing a lot of the thinking for us, about how their tools should be well applied and handle complexity. Tools like Codex and Claude Code have been gaining sophisticated agentic capabilities to do quite a lot of sensible, multi-step workflows far beyond code generation, with little or no direction. I've been impressed by performance analysis, accessibility analysis, code review capabilities (even of the agent's own code in the same session) and proactive subagent initialisation, to name but a few features. Sometimes these things happen automatically, sometimes they just need a simple skill command that comes with the product by default. The context we set in our project might help (e.g. 'I value performance'), but we really get a lot of sensible functionality and behaviour built-in.

A couple of years ago, we might have imagined needing to do significant 'orchestration' ourselves, in order to turn vanilla LLMs from code-emitters into effective, multi-functional development agents, but we should have predicted that the labs would get there first. On this trajectory, we can perhaps imagine that only specialist use cases will ever need to diverge from whatever the mainstream AI tools ship as plug-and-play functionality. Maybe we're already there.

BMad method

https://docs.bmad-method.org/ 

They say: 'BMad adds a set of named commands, called skills, to AI coding tools such as Claude Code and Cursor. Some of them help you think: explore an idea, research it, argue against it, and write down what you have settled on. Others help you build: give bmad-build a change you want made, and it writes the code and reviews it.'

BMad provides a set of skills designed to help us apply Claude or Cursor in a variety of agentic ways. You could use its skills just for research and ideation, or you could trigger more autonomous behaviour: feed it a ticket and let it go away and do the development and reviewing, starting subagents as it sees fit.

It sounds good, but I wonder whether this is the kind of thing that is becoming less relevant as the AI development tools themselves become more sophisticated and ship these capabilities as standard. (As mentioned above.) Admittedly, I haven't tested BMad at the time of writing and I'm sure it does more than Claude alone, for now, but I'm a little sceptical about its longer-term relevance as a custom add-on.

Competitive Multi-Agent Pattern & Multi-LLM Council

If we do want to go beyond the default behaviour of development agents (as it stands in 2026), this is an interesting option. 

Use two or more different models to develop parallel solutions for the same task. Then, use LLMs (again, maybe different models in parallel) to assess the solution options and either choose one, or iterate again, perhaps merging desirable aspects of the different solutions. May involve voting, done by multiple review agents.

This is an interesting one, as it's very different to human development. However, rising costs might become an argument against this idea.

https://medium.com/@edoardo.schepis/patterns-for-democratic-multi-agent-ai-voting-based-council-part-1-9a9164a173ff 

https://www.mindstudio.ai/blog/multi-model-ai-agent-council 

https://blog.mozilla.ai/the-star-chamber-multi-llm-consensus-for-code-quality/ 

Reverse Spec-to-Code Generation or Spec-Driven AI Synthesis

Principle: We can't define in advance exactly what a solution will look like - the act of development resolves uncertainty, reveals complexity and prompts new ideas. By the time we have an MVP, we probably have a clear picture of the desirable solution, but perhaps not the optimal implementation, as we started the implementation before we had the full picture. If we accept that the first implementation was simply a necessary route to defining a spec, we can throw the first implementation away and then develop a cleaner one, dropping any tech debt or other artifacts of our original ignorance.

This idea was described by Fred Brooks in the 70s. 

With human development and time/cost pressure, we often just keep an imperfect implementation and move on, but AI makes the rewrites much more feasible.

1) Work with an AI tool to produce an initial solution (essentially a thorough prototype), revealing and resolving requirements along the way.

2) Ask AI to write a detailed, technical spec of the solution. (Business logic, architecture, components, data model, API schema, things to avoid, etc.) The existing code may complement the spec and effectively form part of it.

3) Start a fresh session and provide it with the spec, so it can produce a clean solution from scratch.

N.B. You might keep some automated tests that were produced in step 1, to use as context and a guardrail for step 3. Of course, you could also spec the tests in step 2 or 4 and have them reimplemented more cleanly in step 3 or 5 if desired.

This principle can easily be applied at feature-level, as and when we deem it a good idea. It might also be applied at product level, for example in a prototype/MVP phase.

You wouldn't necessarily need to build this into an 'orchestration' as such - you can just do it on demand. However, if you found great value in it, then you certainly could create an orchestration that assesses the potential value of a spec-driven rewrite for every PR, or even a whole project at regular intervals, then goes ahead and does it automatically when needed.

(Heard described on the Pragmatic Engineer podcast - need to check which episode.)

Overviews

https://neo4j.com/blog/agentic-ai/agentic-architecture/ Overview of some patterns.

Factories

Skills

https://github.com/mattpocock/skills/tree/main Matt Pocock's popular AI skills including /grill-me.

https://github.com/peteski22/agent-pragma agent-pragma (formerly claude-pragma) skills to bring more determinism to agentic development. Includes /star-chamber for multi-LLM review.

Videos

Basics

Anthropic: Building effective agents: https://www.anthropic.com/engineering/building-effective-agents 

Covers basic definitions and patterns.