Tutorial 3: Agentic AI - Graph Oriented
In the previous 2 tutorials we have covered a lot of ground in producing specifications for system architectures and a scaffold for an implementation. This diagram environment is more granular and made for getting closer to an implementation from the get go.
The diagram environment is centred around creating an agent workflow using LangGraph, a graph-oriented orchestration framework for stateful execution. It's hard to say whether it's best to jump into the tutorial or their docs first, but it good to get an understanding:
LangGraph Git Repository and Docs
This tutorial targets LangGraph specifically, so it helps to think in terms of graph nodes, edges, shared state, and routing between execution steps. The policy yaml file can be easily edited to target other graph based frameworks if you like.
So open tutorial 3 on the projects page and we can dive in:
Stage 1: Orientation
When you open the diagram you should see something like this:
We have a:
* Start -> the graph entry point where execution begins
* Worker Agent -> a graph node that carries out a delegated task step
* Skill -> a reusable capability the worker can invoke to perform a specific piece of work
* End -> the graph termination point where execution completes
* Tranisitions -> graph edges that define how execution moves from one step to the next
Some of the things we don't have in this diagram are:
* Orchestrator Agent -> a coordination node that routes work between other nodes
* Supervisor Agent -> an oversight node that reviews outputs and decides whether work should continue, be revised, or be escalated
* Tool Gateway -> a mediated access point for external tools or tool-like capabilities
* Execution Context -> an architectural runtime boundary that separates where parts of the graph execute
Have an explore of the context menus for each of these and you can see their are contracts and role descriptions which are much more granular than previous architectural configuration options. These lead to a spec being produced with constraints that lend themselves much more towards more tightly influencing the implementation that in previous tutorials.
Stage 2: Adding a Human in the Loop
You may notice that one of the transitions is red. Select it and then click it to bring up the context menu, the transition mode has been set to needsApproval instead of the default uninterrupted, but there are no approvers attached. An approver can generally be a supervisor agent or a human. In this case we can drag a human operator into the system by clicking the blank space in the diagram to go to the component library and dragging one in.
The human operator in this case isn't designed to be part of the graph network so it has no connections. You can though configure a user prompt and role description that are be incorporated into the specification.
In the red transition click the down arrow next to Approver and you should find a tick box to allow you to select the human operator.
Stage 3: Code Generation
The next stages should be quite familiar, generate outputs from spec, evaluate outputs and if the score is low then regenerate to see if you can get a better task.md. Copy that task.md into a repository with your favourite agentic coding tool and let it turn it into an implementation for you.
Stage 4: Build Out an Orchestrated Agentic System
Next step is to explore the different blocks, pull in an orchestrator to do scheduled tasks, try out distributing a task across multiple nodes in multiple execution boundaries.
If you want to try an agentic tutorial using an imported, non-built-in environment, move on to: