Graph engineering for AI agents means designing an agent system as nodes and edges: each node does one job (code, a model call, a full agent or a person) and each edge decides what runs next. The term went viral in July 2026, but the idea is older; LangGraph, Google ADK 2.0 and Claude Code dynamic workflows all build these graphs. For SEO and PPC, put code where no judgement is needed, an agent where it is, and a person before anything changes an account or goes live.
TL;DR
Graph engineering is a design habit, not a product. You draw an agent system as nodes (each does one job) and edges (each decides what runs next), with approval gates and failure paths written down before anything is built.
The word is new; the idea is not. It went viral on X in July 2026. LangChain calls it the latest name for an established approach, and Anthropic described the same patterns in 2024.
For SEO and PPC, the rule is simple. Use code where no judgement is needed, an agent where it is, and a person before anything spends money, changes an account or goes live.
You already have three AI helpers. One drafts negative keywords, one writes the weekly report and one checks which blog posts are losing clicks. Each works on its own. None knows what the others found, nothing stops the report going out when tracking broke on Tuesday, and you are the glue that holds it together every morning.
Graph engineering is the name for designing that glue on purpose. This guide checks what the term means in November 2026, which tools build these graphs, and what a sensible graph looks like for a Google Ads account and an SEO programme. If you want one designed and built for your team, that is what my AI agent development service does, with Google Ads and SEO work as the usual starting points.
A note on evidence. Framework facts come from the LangChain, Google ADK, Anthropic and OpenAI docs, read on 18 November 2026. Version numbers and download counts come from PyPI on the same day. Where I write "I", it describes my own working habits. No client names or client figures appear here.
What is graph engineering for AI agents?
Short answer: It is designing an AI agent system as a graph: nodes that each do one job, edges that decide what runs next, and shared state that carries results between them. A node can be plain code, a single model call, a full agent run or a person approving something.
LangChain's July 2026 post puts it plainly: nodes do work, edges decide what happens next, and the whole thing behaves like a state machine. The part that changed in 2026 is what fits inside a node. It used to be one model call. Now "a node can be a full agent run", so you can wire whole agents together with fixed rules between them.

For a marketer, the useful translation is this: a graph is the written answer to four questions. What starts the work? Which steps need judgement and which do not? Where must a person say yes? What happens when something fails?
| Term | What it means | Marketing example |
|---|---|---|
| Node | One unit of work | Pull 7 days of search terms |
| Edge | The rule for what runs next | If tracking is broken, stop |
| State | What the nodes share | The list of proposed negatives |
| Gate | A node that waits for a person | Approve before any change |
| Cycle | An edge that loops back | Redo triage if a check fails |
Where did the term come from, and is it really new?
Short answer: The phrase took off on 18 July 2026 after a one-line question on X about whether people had moved from loops to graphs. Within days it had three competing meanings. The core idea, orchestrating models through fixed code paths, was already documented in 2024 and built into frameworks such as LangGraph.
Earlier in 2026 the fashionable word was "loops". The head of Claude Code at Anthropic was widely reported in June 2026 as saying they no longer prompt Claude directly and that their job is to write loops. I could not find the original recording, so treat the wording as reported rather than quoted. Then, on 18 July, a well-known open-source developer asked on X whether we were still talking loops or had shifted to graphs. An AI engineer published an X article declaring loop engineering dead within hours, and the term spread.
The fast spread brought noise. One investigation of the hype found three different meanings within 48 hours: orchestration graphs of agents, graphs of self-improving loops, and knowledge stored as a graph. It also traced a widely shared "Stanford and Anthropic study" behind the trend and found it did not exist. If someone quotes that study to sell you something, ask for the link.
| Date | What happened | Source |
|---|---|---|
| Dec 2024 | Anthropic names workflow patterns | Anthropic |
| Oct 2025 | LangGraph reaches 1.0 | LangChain blog |
| May 2026 | Google ADK 2.0 moves to a graph engine | ADK docs |
| Jun 2026 | Claude Code dynamic workflows | Claude blog |
| 18 Jul 2026 | The loops or graphs post on X | X |
| 22 Jul 2026 | LangChain: not a new idea | LangChain blog |
| Aug 2026 | Academic survey on graph engineering | arXiv |
| 30 Nov 2026 | OpenAI Agent Builder shuts down | OpenAI docs |
So is it real? Yes, as a design habit. One balanced review sums it up well: a loop is already a graph, routing is moving into code while the model handles judgement, and state machines and workflow engines have done this for decades. What is new is that the boxes on the diagram can now be capable agents. That is what makes the design matter more.
How do prompts, skills, loops and graphs fit together?
Short answer: Think of a ladder. A prompt helps once. A skill saves a method so it works every time. A loop runs that skill on a schedule without you. A graph connects several loops and agents and decides which runs next, including when to stop and when to wait for a person.

Most marketing teams are still on the first rung. That is not a failure: you cannot design a good graph out of steps you have never run by hand. Teams that draw the graph first tend to end up with a clever diagram and nothing that works.
| Rung | What it is | Who decides next step | PPC example |
|---|---|---|---|
| Prompt | One question, one answer | You | Ideas for negatives |
| Skill | A saved method | The model, following it | Search terms triage |
| Loop | A skill on a trigger | The schedule | Daily 7am triage |
| Graph | Connected loops and gates | The edges you wrote | Check, triage, approve, log |
If you are unsure whether a job needs an agent at all, read AI workflows vs agents first. Most marketing jobs are workflows with one or two agent steps inside, which is exactly what a graph lets you express.
Which frameworks build agent graphs in November 2026?
Short answer: LangGraph is the most used dedicated option. Google's ADK 2.0 rebuilt itself around a graph engine in 2026, Claude Code can write and run graph-like workflows from a prompt, and CrewAI, Pydantic AI and the OpenAI Agents SDK cover the same ground in different styles. OpenAI's visual Agent Builder shuts down on 30 November 2026.
| Tool | Graph style | Pause for a person | Fits |
|---|---|---|---|
| LangGraph 1.2 | Nodes, edges, state | interrupt() | Developers, any model |
| Google ADK 2.x | Graph engine, nodes | Built in | Google Cloud teams |
| Claude Code workflows | A script Claude writes | Between workflows | Teams already on Claude |
| CrewAI Flows | Start, listen, router | human_feedback | Python teams |
| Pydantic AI graph | Typed nodes | Your code | Typed Python apps |
| OpenAI Agents SDK | Agents and handoffs | Built in | OpenAI-first teams |
LangGraph describes itself as a low-level orchestration framework for long-running, stateful agents. It reached version 1.0 on 22 October 2025 with a promise of no breaking changes until 2.0, and version 1.2.22 shipped on 14 November 2026. Its interrupt() function pauses a graph, saves its state and waits indefinitely for a person, which is the feature that matters most for ad accounts.

Google's Agent Development Kit 2.0 reached general availability for Python on 19 May 2026, Go on 30 June and TypeScript on 21 August. Its docs say agents, tools and functions now run as nodes in a workflow graph, and workflows can pause for human input. Google's developer blog explains why it moved from a hierarchy of agents to a graph.

Claude Code took a different route. Its dynamic workflows, introduced in a June 2026 Claude blog post, are JavaScript scripts that Claude writes for your task and a runtime executes in the background. The docs draw the key line clearly: with subagents and skills, Claude decides turn by turn what runs next; with a workflow, the script decides.

Two limits from those docs shape marketing use. A workflow takes no input from you mid-run, so for sign-off between stages you run each stage as its own workflow. And the Claude blog warns that workflows "often use more tokens" and suit complex, high-value tasks, not every job. For daily account checks, a scheduled task that runs a skill is usually cheaper.
If you used OpenAI's drag-and-drop Agent Builder, plan a move now. Its docs say it is being deprecated and is scheduled to shut down on 30 November 2026. The Agents SDK and ChatKit remain.

For a wider list of open-source agent and marketing repositories, with what each does for a business, see the 30 best GitHub repos to run your business with AI.
What does an agent graph look like for a Google Ads account?
Short answer: A daily search terms graph is the best first build. Code checks tracking and pulls data, one agent node triages terms, code checks the proposals for conflicts, a person approves, and code applies only what was approved and logs it. If tracking is broken, the graph stops before anything else runs.

| Node | Type | Output | If it fails |
|---|---|---|---|
| Tracking check | Code | Pass or stop | Alert, end run |
| Pull search terms | Code | 7-day table | Retry once, alert |
| Triage terms | Agent | Proposed negatives | Flag, no output |
| Conflict check | Code | Clean list | Back to triage, max 2 |
| Approval | Person | Yes, edit or no | Waits; nothing applied |
| Apply and log | Code | Change log row | Stop; no retry |
Notice how few agent nodes there are. Pulling a report and comparing two lists need no judgement, so they are code: cheaper, faster and the same every time. The agent sits only where judgement is needed, deciding whether "cheap" in a search term means a bargain hunter or a good lead.
The graph also has to respect what the tools can do. Google's official Ads MCP server reads account data and, since version 0.0.6 on 2 November 2026, can create assets and labels through a propose and confirm step. Adding negatives or changing budgets needs the Google Ads API, where a new Google Cloud project starts at Test level and Explorer access allows up to 2,880 operations a day on live accounts. The full tool picture is in AI agents for PPC.
Two engineering details decide whether this graph is safe. First, the apply node must not run twice. A r/LangChain thread showed that if a node crashes right after a payment call, resuming the run sends the payment again, because the saved state is from before that node. LangGraph's own interrupt docs warn that a resumed node restarts from the beginning. Second, approvals must fail loudly. Another r/LangChain thread found that resuming a finished run with "rejected" quietly returned the old "approved" result. Keep your own approvals table as the record.
It is also how I like to run ad account work with AI, with or without graph software: audit first, put the findings in a sheet, check them by hand, and change nothing before approval. A graph just writes that habit down so a machine can follow it.
What does an agent graph look like for SEO?
Short answer: A content refresh graph works well: code pulls Search Console data and flags pages losing clicks, an agent diagnoses why and drafts a brief, a second agent fact-checks the draft, and a person approves before anything is published. Publishing stays behind a human gate.
| Node | Type | Does what | Gate |
|---|---|---|---|
| Search Console pull | Code | Clicks by page, 28 days | None |
| Decay filter | Code | Flags pages down most | None |
| Diagnose | Agent | Why it lost clicks | None |
| Brief and draft | Agent | Update plan, new copy | None |
| Fact check | Agent | Checks claims, links | Back to draft |
| Editor review | Person | Approves or edits | Required |
The pull node is plain code against the Search Console API, which allows 1,200 Search Analytics queries a minute per site. That is plenty for a weekly run; the bottleneck is the editor, not the API.
The human gate is not optional caution. Google's spam policies name "using generative AI tools or other similar tools to generate many pages without adding value for users" as an example of scaled content abuse. A graph that publishes on its own is a fast way to produce exactly that. My own longer build for this is in how to build an AI SEO system.
A busy r/SEO thread from a founder who tried several tools and agents and still had near-zero traffic makes the same point from the other side. The most useful reply was to stop acting on tool recommendations for a while and start with Search Console: which pages are indexed and which queries already earn impressions. A graph cannot fix a missing diagnosis; it only repeats it faster.
How do you draw the graph before you build it?
Short answer: Write a one-page graph spec: the trigger, each node with its type, input and output, the edges and their conditions, failure paths with retry limits, approval gates, side effects, and what each run logs. Then ask which nodes are most likely to go wrong.
Paste this into Claude, ChatGPT or Gemini with one real task. The output is a spec you can review with your team before anyone writes code or connects an account.
I want to turn a marketing task into an agent graph. Do not build anything yet. Task: [for example, the daily Google Ads search terms review for one account] Write a one-page graph spec with: 1. Trigger: what starts a run (schedule, new data, a person). 2. Nodes: for each step, its name, type (code, single model call, agent, or person), input, output format, and the tools it may use. Prefer code wherever no judgement is needed. 3. Edges: what decides the next node, including every condition and branch. 4. Failure paths: what happens when data is missing, a check fails or a node errors. Every retry needs a maximum count. 5. Approval gates: which nodes wait for a person, and what that person sees. 6. Side effects: every node that changes an account or publishes something, and how a retry avoids doing it twice. 7. Log: what each run records (proposed, approved, rejected, why). Then list the three nodes most likely to go wrong and how I would notice.
| Rule | Why | PPC example |
|---|---|---|
| One job per node | Easy to test alone | Triage only triages |
| Code before agents | Cheaper, repeatable | Code pulls the report |
| Typed handoffs | Next node can trust it | Term, cost, reason |
| Limit every cycle | No runaway cost | Redo triage twice |
| Gate side effects | Money moves need a yes | Approval before apply |
| Log every run | You can audit it | Proposed vs approved |
Two more design rules are worth adding. Give each client or account its own folder, credentials and graph, so one account's context never leaks into another. And separate doing from checking: the Claude Code workflow docs describe independent agents reviewing each other's findings before anything is reported. In graph terms, the reviewer is its own node and never marks its own homework.
Which tool should a marketing team actually use?
Short answer: Start with the tool your team already uses. Claude users can get far with skills, scheduled tasks and dynamic workflows. Teams with a developer and several model providers should look at LangGraph. Google Cloud teams should look at ADK 2.0. No-code tools suit simple linear jobs.
| Your team | Start with | Move up when |
|---|---|---|
| No developer | Skills and schedules | You need branches |
| On Claude already | Claude Code workflows | You need mid-run approval |
| Has a developer | LangGraph | You need many providers |
| On Google Cloud | ADK 2.0 | You need Vertex AI hosting |
| Used Agent Builder | Agents SDK or ChatKit | Before 30 Nov 2026 |
Whatever you pick, the graph spec stays the same. That is the real asset: a written design you can rebuild in another tool when prices, models or vendors change.
What goes wrong with agent graphs?
Short answer: Cost runs away when agents fan out, approvals get lost without errors, side effects repeat on retry, and agents optimise the signal you gave them instead of the one you meant. Each has a simple guard if you design for it.
| Failure | Guard |
|---|---|
| Token spend balloons | Budget per run, limit fan-out |
| Approval silently lost | Own approvals table |
| Change applied twice | Idempotency key per change |
| Agent chases cheap leads | Feed qualified lead data |
| Bad data, confident output | Tracking check first |
The cost point is real. In an r/LangChain thread on budget caps, the top reply says to record each node's actual token use against a per-run budget and check it before the next call, because an iteration limit will not cap one expensive call. In r/ClaudeCode, a team cut workflow token spend to about a fifth by having Claude turn repeated steps into fixed scripts. That is graph engineering in miniature: move what does not need judgement into code.
The PPC point matters most for ad accounts. A r/PPC thread titled "The eval was harder than the agent" describes an agent that improved cost per conversion while cheaper conversions stopped turning into good pipeline. Nothing was broken; the agent chased the easy signal. Replies recommend feeding back a downstream field such as qualified stage from the CRM and stepping in when spend moves a lot. A graph makes that check a node instead of a hope.
What do people say on X and Reddit?
Short answer: Builders broadly agree the label is hype but the habit is useful. The practical threads are about approvals, cost and side effects, not about the word itself.
Posts and threads checked on 18 November 2026. Reddit replies are opinions; one thread comes from a vendor.
| Where | Date | What it says | Type |
|---|---|---|---|
| An open-source developer, X | 18 Jul 2026 | Loops or graphs yet? The post that started it | Opinion |
| An AI engineer, X | 18 Jul 2026 | X article: loop engineering is dead | Opinion |
| An AI author, X | 18 Jul 2026 | Early long essay on graphs of agents | Opinion |
| A state machine library author, X | 20 Jul 2026 | A loop is a directed cyclic graph | Opinion |
| An AI builder, X | 21 Jul 2026 | Guide: nodes, edges, verifiers | Opinion |
| r/LangChain | 4 Sept 2026 | LangGraph is one agent; graph engineering is many | Opinion |
| r/AI_Agents | 8 Oct 2026 | Design human sign-off in from day one | First-hand |
| r/PPC | 14 Sept 2026 | Agent chased cheap conversions | First-hand |
| r/LangChain | 16 Nov 2026 | Rejected approval silently ignored | First-hand |
| r/LangChain | 8 Nov 2026 | Resume repeated a payment | Vendor |
| r/ClaudeCode | 6 Sept 2026 | Scripts cut workflow tokens | First-hand |
The r/AI_Agents post from a builder with about five years of assistant systems behind them is the best short read. Their advice: make the flow something you can look at, treat human sign-off as a starting assumption rather than a later feature, and keep the model choice in one place so a cheap step does not quietly run on an expensive model.
Which videos explain graph engineering well?
Short answer: Start with Google Cloud's Graph Engineering 101, then LangChain's one-minute LangGraph explainer, then the Claude Code team on how they work now. All six below were checked on YouTube on 18 November 2026.
Graph Engineering 101, Google Cloud Tech, September 2026. A conversational introduction to nodes, edges and control in multi-agent systems. Official, and it points to Google's ADK codelab.
LangGraph explained in 1 minute, LangChain, October 2026. The vendor's own short explainer of why predictable multi-step agents need a graph.
How the Claude Code team uses Claude Code, Claude, September 2026. Anthropic staff on moving from prompting and approving every step to running work in parallel. Official.
| Video | Channel | Date | What it covers |
|---|---|---|---|
| Graph Engineering 101 | Google Cloud Tech | Sept 2026 | The concept |
| Graph Engineering with ADK | Google Cloud Tech | Sept 2026 | Hands-on ADK build |
| LangGraph explained in 1 minute | LangChain | Oct 2026 | Why graphs |
| Building LangChain and LangGraph 1.0 | LangChain | Oct 2025 | The 1.0 release |
| How the Claude Code team uses Claude Code | Claude | Sept 2026 | Parallel agent work |
| Make Your AI Agents Predictable With Graph Engineering | AI Engineer | Nov 2026 | Conference talk, graph vendor |
Where this advice is weak
Short answer: The tools change monthly and the term has no agreed definition, so check versions and limits on the linked pages before you build, and treat the graphs here as patterns, not tested products.
- The PPC and SEO graphs are worked examples of a design pattern. Your thresholds, accounts and tools will differ.
- Download counts measure installs, including automated builds, not how many teams run agents in production.
- I have not benchmarked the frameworks against each other; the comparison table is from their docs.
- The widely reported quote about writing loops could not be traced to an original recording.
- Graph-based knowledge stores (knowledge graphs, GraphRAG) are a separate topic this guide does not cover.
What does this change about your role?
Short answer: You move from operator to designer. An operator pulls the report and makes the change. A designer decides what the system checks every morning, what counts as a problem, which steps need judgement and who approves the fix.
The designer's job is more valuable and tiring in a different way. You think about failure cases, write unambiguous rules and review results critically. What to learn changes too: how data flows between tools, how to write instructions a machine cannot misread, and how to tell whether a node is doing its job matter more than memorising platform menus.
Start small. Pick the one task you do by hand every week, turn it into a skill, run it for a few weeks, schedule it as a loop, and only then connect it to a second loop with a gate in between. That is a graph, and you will understand every edge in it because you walked it yourself first.
Want help designing an agent graph for SEO or PPC?
Short answer: Bring one recurring task and your current tools; I will turn it into a graph spec with gates and failure paths, then build it in the tool you already use.
I design and build these systems through my AI agent development service, usually starting with Google Ads management or SEO consulting where the payoff is easiest to measure. Rates are on the pricing page.
Keep reading: AI workflows vs agents, the best GitHub repos to run your business with AI, AI agents for PPC and how to build an AI SEO system.
Sources
| Source | What it supports | Date | Link |
|---|---|---|---|
| LangChain blog | Definition, not a new idea | 22 Jul 2026 | 3 years of graph engineering |
| LangChain blog | LangGraph 1.0, no breaking changes | 22 Oct 2025 | LangGraph 1.0 |
| LangGraph docs | Overview, interrupt() | Read 18 Nov 2026 | Interrupts |
| GitHub | LangGraph 1.2.22 | 14 Nov 2026 | Releases |
| Google ADK docs | Graph engine, GA dates | Read 18 Nov 2026 | ADK 2.0 |
| Claude Code docs | Workflows, limits | Read 18 Nov 2026 | Dynamic workflows |
| Claude blog | Workflow launch, token warning | 2 Jun 2026 | A harness for every task |
| OpenAI docs | Agent Builder shutdown | Read 18 Nov 2026 | Agent Builder |
| Anthropic | Workflows vs agents | 19 Dec 2024 | Building effective agents |
| PyPI stats | Downloads, versions | Read 18 Nov 2026 | pypistats.org |
| The AI Operator | Three meanings, fake study | Jul 2026 | What is graph engineering |
| Google Search Central | Scaled content abuse | Read 18 Nov 2026 | Spam policies |
| Google Ads API docs | Access levels | Read 18 Nov 2026 | Access levels |
| X and Reddit | Practitioner views | Jul to Nov 2026 | Linked in the table above |
This article expands on my post on LinkedIn ↗.
FAQ
What is graph engineering for AI agents?
It is designing an AI agent system as nodes and edges. Each node does one job, such as running code, calling a model, running a full agent or waiting for a person, and each edge decides what runs next, including branches, retries and stops.
Who coined the term graph engineering?
Nobody owns it. The phrase spread on X from 18 July 2026 after a developer asked whether people had moved from loops to graphs, and LangChain argued days later that it is the latest name for an established approach it has used in LangGraph for three years.
Is graph engineering the same as LangGraph?
No. LangGraph is one framework for building agent graphs. Graph engineering is the design habit, and you can apply it in Google ADK 2.0, Claude Code dynamic workflows, CrewAI Flows or plain code.
What is the latest version of LangGraph?
On 18 November 2026 the latest Python release was LangGraph 1.2.22, published on 14 November 2026. LangGraph reached 1.0 on 22 October 2025 with a promise of no breaking changes until 2.0.
Do marketers need to code to use graph engineering?
No. You can write the graph spec yourself: trigger, nodes, edges, failure paths and approval gates. A developer or a tool such as Claude Code can then build it, and the spec lets you check what was built.
How does graph engineering apply to Google Ads?
Build a daily search terms graph: code checks tracking and pulls data, one agent proposes negatives, code checks them against converting terms, you approve, and code applies only approved changes and logs them. If tracking is broken, the graph stops.
How does graph engineering apply to SEO?
A content refresh graph pulls Search Console data, flags pages losing clicks, has an agent diagnose and draft updates, has a second agent fact-check, and waits for an editor before publishing. Google's spam policies make that human gate important.
Is OpenAI Agent Builder still available?
Only until the end of November 2026. OpenAI's docs say Agent Builder is being deprecated and is scheduled to shut down on 30 November 2026, while ChatKit and the Agents SDK remain available.





