graph engineering explained (marketing edition) graph engineering is about designing the map your agents run inside, you draw the steps and the routes between them ahead of time, then they travel the path you put down it is the layer past looping, where one agent just circles a single task until the work meets the standard you set every agent graph is built from 4 pieces: > nodes: a stage the work passes through, research, draft, score, publish, a few run once, others are their own loop the agent circles until that step clears > routes: the paths you draw between the nodes ahead of time, every direction the work is allowed to travel > checkpoints: the check on each route that reads the result and sends the work forward when it clears or back to an earlier node when it misses > gates: a checkpoint the work cannot skip, nothing publishes until the draft clears the rubric if you have built a workflow in n8n you have already drawn one, nodes you connected, branches that fire on a condition, a step that loops until it clears. an agent graph is that same shape, each node holds an agent doing the work n8n would hand to a single api call the content graphs I run at my agency all take this shape, here is one you can build for SEO > 1 research: pull the keyword, the search intent, the competitors ranking for it, and the questions people keep asking > 2 brief: turn that research into a brief, the angle, the entities to cover, the queries the piece has to answer > 3 draft: an agent writes the article from the brief and nothing else in its context > 4 score: a critic grades the draft against your rubric, depth, intent match, originality. this node is a loop, it sends the weak drafts back to 3 and only releases one that clears > 5 publish: once the rubric clears and the brand rules pass, the agent adds internal links and the piece goes live each arrow between those is a route, every grade is a checkpoint that picks which route the work takes next, and the draft and score nodes form a loop inside the bigger map while the rest run once this is where the word graph starts to mislead. that draft and score loop can pass itself, the critic likes the draft, its rubric clears, it publishes, and still never ranks. the loop was grading the writing against another agent's opinion while the only thing that counts is whether it ranked so you add a checkpoint the agents cannot argue with, one that reads live search and AEO signals from outside the graph: > did google index it > is it climbing on the target query > are AI answers citing it > do people stay once they land if those move, the map keeps its shape and you feed it the next keyword. a stall sends the work back to research instead, because a miss this late usually traces to the angle or the intent you chose at the start, which a rewrite cannot fix anchor the map to results the agents cannot fake, and freeze the few rules they never rewrite, your brand voice and the claims you cannot make with the anchor in place, a failed piece shows you the exact node it broke on

what's the difference between a loop and a graph? (marketing edition) both are ways to run an agent, the difference is who decides the path, the agent or you. a loop still starts with you. you set the goal, the brief, and the bar it has to clear. what the agent owns is the path. take writing an SEO article: hand it the brief and it drafts, reads the draft back against that brief, rewrites the weak parts, checks again, and keeps circling until it clears the bar. the one thing you did not write is the step-by-step it took to get there. a graph is you drawing the steps and the routes between them ahead of time. same article, but now you set the map: research the keyword and the competitors ranking for it. draft from what you find. score that draft against your rubric. if it clears, add the internal links and publish. if it misses, back to the draft. the agent still decides how to handle each step, it just travels the routes you laid down. the shape of this has a name, a state machine. every node is a state the work can be in, and a check at each one decides where it goes next, forward when it clears or back to an earlier node when it misses. if you have built a workflow in n8n, you have already drawn one. nodes wired together, branches that fire on a condition, a step that loops until it clears, that picture is a graph. an agent graph is the same shape, the nodes hold agents doing the work instead of single api calls. the way I think about it, a graph is a map of loops and checkpoints. some nodes run once, others are their own loop where the agent works something out, and the checkpoints between them read the result and route the work. you keep laying down nodes and checkpoints until the map reliably gives you the output you want. the vault accelerator I run at my agency is one of these maps, 3 sessions that hand off in a fixed order: > research session: reads our company brain and past campaign results, pulls in competitor and market context, and builds the cohort we go after > landing page session: takes that research and builds the page from it > content session: uses the research and the page to write the copy, illustrations, and slides for the live sessions we run inside the content session runs a loop, a critic scores each draft against a rubric and sends it back until it clears the bar. that is one node on the map, the checkpoints between the sessions carry the work from one to the next a graph earns its extra setup on anything you run every week: > validation gates the work cannot skip > a fixed set of routes the job can take > a clear failure point, you see the exact step something broke on a loop on its own is enough for the work you only do once, where you don't know the path yet, let the agent find it. graphs earn their place on the jobs you repeat, the content pipeline, the SEO and AEO funnel step by step, the vault accelerator once the map works you reuse it, feed it the next cohort and the whole pipeline runs again past the loop, the next thing you design is the map it runs inside.

how a simple llm wiki compares to gbrain second brains are getting popular fast, they're one of the main enablers for ai and agents right now. the context you give an agent is what makes it good two frameworks I've been using are the LLM Wiki and Gbrain. here's how they compare, and how to use both underneath they're the same idea, karpathy's llm wiki: you compile raw sources into linked markdown pages your agent reads, instead of redoing RAG from scratch every time both ingest your sources, build a graph out of them, and answer with citations, so the real question is what's actually different an LLM wiki is just markdown and your agent: > it reads your sources and writes linked pages > you ask a question and it reads those pages to answer > you keep it healthy with a lint pass > there's no database, just files, and one user it works well, and karpathy even points out where it starts to break down: > the synthesis drifts after a lot of updates > the context cost grows as the wiki gets big > a wrong claim can harden into fact over time gbrain is that same wiki with an engine built for those exact problems: > better retrieval, vector plus graph plus a reranker, instead of the agent reading pages > it runs on postgres, so it scales past what you could ever read yourself > a 24/7 loop enriches and fixes the wiki on its own, so there's no manual lint > every answer comes with sources and an honest note on what it doesn't know yet > it's multi-user, with access scoped per person and team when to reach for each: > use an llm wiki for smaller projects, to gather and store the context an agent will use later on. when it grows up, you can ingest it straight into gbrain > use gbrain for the consistent, shared things, a company brain or a client brain, especially once more people are involved so it's not wiki vs brain, it's the same wiki run by you on a small project, versus the same wiki run by an engine at scale for a team start simple, then move to gbrain when you outgrow the files

how to set up your Hermes Agent control room send this image + the repo below to your agent and it will configure itself based on the blueprint this is the same architecture I use to run specialist agents across both my agencies