ALDC started out playing. I would hand a document to the developer agent and let it work, just to see what came out. There was no framework. There was curiosity.

The architect appeared almost immediately, and this matters for what comes later: I did not add it because the developer was designing while implementing and gave me a fright. It was there from nearly the first moment. What grew was not the cast of agents, it was the depth of the architect, until refined technical specifications stopped being a note and became the artefact everything else worked on top of.

With that artefact on the table came orchestration with subagents, and the conductor, which collects the state of each phase and decides when the next one can start. That is where the loop closed.

The human gate did not arrive afterwards, as a governance layer bolted on once things got serious. It was born with the architect, because somebody has to approve the architecture document before a single line gets written. When the conductor arrived, that same principle extended to every phase. And what I understood inside that loop is that human approval was not a process ornament. It was a condition of the flow.

What I wanted ALDC to reflect, and what ends up expressed in its loop, is the ordinary flow of AL extension development: one where human approval, validation, testing and confirming scope carry as much weight as the code.

The road continued

Once the ALDC core was in place, ideas started appearing for agents I needed in order to cover new developments or new programming paradigms as they showed up. Agents for building Business Central agents, which is where CIRCE comes from. Another attempt at something that could help me with technical presales.

They were agents that perhaps never carried much weight, but they came out of trying to fit other uses inside ALDC and its concept. They started as agents. Later I realised they could probably have been skills. That is what living through the moment when a set of tools appears looks like: some primitives arrive, and then the actual use inside the different harnesses pushes you to turn them into skills, or to overuse them.

Greenfield worked. Brownfield was the turning point

The real turning point was production work with ALDC and the feedback that came back from it. Not only on greenfield projects, but on brownfield ones: projects already underway, projects with development well advanced, or plain support work.

ALDC works very well on greenfield. That much is obvious. On brownfield, and on incident handling, what I had built turned out to be too rigid. There you need a certain agility.

First you need to identify clearly where the error is. You also need to audit. So I built two agents focused on triage and audit, and I built them at the same time.

Triage diagnoses the error and, above all, its blast radius, because in Business Central the error you see is rarely the error you have. Dredd audits, and it audits against two things: good practices and the skills that ship with ALDC, and whether what was implemented meets the business criteria that the architecture and the specs had carried across. That second half is what separates it from a linter. A linter tells you the code is well written. Dredd tells you whether the code does what everyone agreed it would do.

BCQuality, and the difference between deducing and knowing

Both Dredd and Triage, and any of the subagents doing code review, use BCQuality as their knowledge backing. It is an open source project from the Business Central development team at Microsoft, and it arrived later than the rest.

What it contributes is not one more review. It is certainty. Until then the agents deduced what counted as quality code from skills and good practices, which work but argue only for themselves. With BCQuality the technical detection rests on knowledge that is held up by something.

Where we are now, almost twelve months in

And that is where twelve months of framework leave me in an uncomfortable place. Uncomfortable because this moves very fast. Concepts like loop appear. Concepts like graph appear.

ALDC was clearly a loop from the start. But the graph concept has genuinely made me think about a refounding of ALDC, to take in everything good that this way of organising agents brings. The same goes for harnesses and the capabilities each of them offers. ALDC has to adapt to each one, or at least come in different flavours.

In the end the main gap that worries me in ALDC is context. That context nobody gave to the agent team, or to any agent in particular. Everything the agent does not know that it does not know. That is the main gap, and what the graph tries to mitigate, or at least make us aware of: how far it actually knows. On one side by giving it tools so it has more context, on the other by having evidence of what it knows.

Another important point after twelve months is that agents should actually receive the information they need, and that the answer or result they produce should be the one the next agent genuinely needs. That saves a great many re-reads and, obviously, tokens. But it complicates the general architecture of ALDC, because it brings in artefacts that are not really primitives. Not skills, not agents, not prompts, not instructions. We now need tools that provide clear determinism.

The progress I already have on that front, in ALDC Graph, matters. It is still in development.

One last thing. Practically all the documentation and artefacts we hand back when working with code agents are markdown, because that is what we were pointed at from the start. There is now a bit of a trend towards showing certain information in HTML, especially at the human validation gates, because nobody reads a markdown file that runs to hundreds of lines. That is probably a topic for another post, or another saga.

Graph Saga

This post is part of the Graph Saga, a series about what I am learning and needing around agentic AI applied to code, and to projects like ALDC. The aim is always to bring it closer to Business Central. Not every post will do that on the surface, but underneath and between the lines it is there.