[{"data":1,"prerenderedAt":4862},["ShallowReactive",2],{"blog-sorted":3},[4,295,448,707,1051,1642,2012,2505,2851,3150,3461,3719,4111,4239,4455],{"id":5,"title":6,"body":7,"description":13,"extension":284,"meta":285,"navigation":289,"path":290,"seo":291,"sitemap":292,"stem":293,"__hash__":294},"blog\u002Fblog\u002Fwe-have-been-drawing-flows-for-20-years-but-we-are-not-using-their-power.md","We Have Been Drawing Flows for 20 Years. But We Are Not Using Their Power",{"type":8,"value":9,"toc":272},"minimark",[10,14,17,20,23,28,31,34,73,76,80,83,86,89,92,96,99,105,111,117,120,124,127,133,139,145,148,152,155,158,161,164,168,185,188,191,195,204,210,216,222,228,234,240,246,249,253,256,259,262,265],[11,12,13],"p",{},"For two decades now, we have been dragging nodes onto canvases, connecting them with arrows, and calling the result a \"flow.\" Chatbot builders, automation tools, LLM orchestrators, form designers. Every single one of them shows you the same picture: boxes connected by lines. And every single one of them quietly wastes what that picture actually is.",[11,15,16],{},"Because here is the uncomfortable truth. When you design a flow visually, you are not drawing a flow. You are drawing a network graph. A structure that, in mathematics, biology, neuroscience, and computer science, belongs to the most powerful organizing principles we know of.",[11,18,19],{},"And yet, flow builders use this structure for exactly one thing: telling the runtime what happens next.",[11,21,22],{},"That is like buying a Formula 1 car to drive it to the mailbox.",[24,25,27],"h2",{"id":26},"networks-are-one-of-the-most-powerful-structures-in-nature","Networks are one of the most powerful structures in nature",[11,29,30],{},"Look around. Neurons in your brain. Mycelium under a forest floor. Power grids. Protein interactions. Social ties. Road systems. The internet itself. Whenever nature or engineering needs to solve a hard, adaptive, distributed problem, the answer tends to look the same: a network of nodes connected by edges.",[11,32,33],{},"Why? Because networks can do things that linear sequences fundamentally cannot.",[35,36,37,46,53,60,67],"ul",{},[38,39,40,41,45],"li",{},"Networks can ",[42,43,44],"strong",{},"loop back",". A signal can return, revisit, reconsider.",[38,47,48,49,52],{},"Nodes can ",[42,50,51],{},"know each other",". They can exchange data without a strict parent and child relationship.",[38,54,55,56,59],{},"Networks can be ",[42,57,58],{},"traversed in many ways",". There is rarely one path. There are paths, plural, and the best one depends on the current state of the world.",[38,61,62,63,66],{},"Multiple regions can be ",[42,64,65],{},"active at the same time",". Parallelism is native, not a feature you bolt on.",[38,68,40,69,72],{},[42,70,71],{},"adapt",". Activating one region can deactivate another. Energy, attention, or signal can shift across the whole structure as conditions change.",[11,74,75],{},"This is the energy sitting on every flow builder canvas you have ever opened. And almost none of it is harnessed.",[24,77,79],{"id":78},"what-flow-builders-actually-do-with-all-that-power","What flow builders actually do with all that power",[11,81,82],{},"Open Botpress. Voiceflow. n8n. Make. Pick your favorite. The graph on screen is treated as a glorified arrow diagram. The edge means one thing and one thing only: \"after this node, go to that node.\"",[11,84,85],{},"That is it. Twenty years of progress and the edge is still a fancy \"then.\"",[11,87,88],{},"Everything a real network can do has been amputated. There is no real backtracking, no shared context between distant nodes, no native parallelism, no concept of a path that can be invalidated and rerouted. The graph is a wireframe for a sequence, not a living structure.",[11,90,91],{},"And so the moment your flow needs to behave like a real network, you fall off a cliff.",[24,93,95],{"id":94},"the-consequences-of-ignoring-the-network","The consequences of ignoring the network",[11,97,98],{},"This is not a theoretical complaint. It shows up in the daily pain of anyone who has ever shipped a serious flow.",[11,100,101,104],{},[42,102,103],{},"Backtracking requires manual code."," A user changes their mind three steps ago. In a real network, that is a state change that ripples through the graph. In a typical flow builder, it is a problem you solve with custom logic, hidden conditions inside nodes, and a private collection of curse words.",[11,106,107,110],{},[42,108,109],{},"Bots block when they show an interface."," The moment a chatbot displays a form, a button group, or a configurator, the entire conversation freezes until the user finishes. Why? Because the underlying engine has no concept of multiple regions being alive at the same time. A real network would let the form sit there while the bot keeps reacting, sending hints, validating, or responding to side events. But the flow builder only knows \"next.\"",[11,112,113,116],{},[42,114,115],{},"Multiple intents are nearly impossible to handle."," A user writes \"I want to cancel my order and also change my email.\" Two intents in one sentence. A network could activate both relevant regions and serialize them cleanly. A linear flow builder picks one, drops the other, or routes you into a \"sorry, I did not understand\" loop.",[11,118,119],{},"These are not edge cases. These are everyday flows. And the tools we have were never built to handle them, because the network underneath was never allowed to behave like a network.",[24,121,123],{"id":122},"the-three-escape-hatches-the-big-builders-offer-and-why-they-all-fail","The three escape hatches the big builders offer (and why they all fail)",[11,125,126],{},"When the architecture cannot solve the problem, the vendor sells you a workaround. There are essentially three on the market today, and each one creates a new problem instead of fixing the old one.",[11,128,129,132],{},[42,130,131],{},"1. Restarts",": \"The user said something unexpected? Restart the flow. The state got messy? Restart. Something changed mid conversation? Restart.\" This is pain pushed directly onto the user. Imagine a website where every misclick sent you back to the homepage. We would call that broken. In flow builders, we call it a feature.",[11,134,135,138],{},[42,136,137],{},"2. Code nodes",": \"Cannot express it in the graph? Drop in a code node and write JavaScript.\" This is pain pushed onto the agency or developer. You end up mixing imperative code with visual flow, creating an unmaintainable hybrid where half the logic is on the canvas and half is buried in script fields. Six months later nobody knows where anything lives. The graph lies about what the system actually does.",[11,140,141,144],{},[42,142,143],{},"3. LLMs as a control layer",": \"Let the model figure it out.\" This is pain pushed onto reliability. LLMs are excellent at fuzzy understanding and terrible at deterministic expert flows. Try running a regulated intake form, a medical screening, or a precise product configurator through a free floating LLM and see how many compliance officers want to talk to you. The moment you hand the steering wheel to a probabilistic model, you have lost the guarantees that made a flow worth drawing in the first place. For deterministic, auditable, expert grade flows, \"let the model decide\" is not an answer. It is a liability.",[11,146,147],{},"All three workarounds exist because the foundation refuses to use the network it pretends to be.",[24,149,151],{"id":150},"but-this-is-not-an-anti-llm-argument","But this is not an anti LLM argument",[11,153,154],{},"It is important to be precise here, because the easy misreading of the previous section is \"Wanderer thinks LLMs do not belong in flows.\" That is not the position. The position is that LLMs do not belong in charge of flows. They belong inside them, as typed components with a clear job.",[11,156,157],{},"In Wanderer, this is exactly how Multi Intent is solved. A user types something like \"I want to cancel my order and also change my email.\" An LLM node receives the prompt, extracts the intents as structured JSON, and that JSON unlocks edges in the graph. The LLM does what it is genuinely good at, which is understanding language. The graph does what it is genuinely good at, which is executing logic deterministically and reproducibly. No model decides business rules. No business logic tries to parse natural language. Each part does the job it was built for.",[11,159,160],{},"That distinction matters more than it looks. It is the difference between using an LLM as a conductor and using it as a sensor. As a conductor, an LLM has to be right about everything, all the time, including things it has no way of knowing. As a sensor, it only has to produce structured output from unstructured input, which is the one task where modern models are reliably strong. The graph takes that output and decides what happens next, based on rules you can read, audit, and trust.",[11,162,163],{},"This is the architecture that survives contact with real users, real regulations, and real edge cases. Not \"LLMs everywhere.\" Not \"LLMs nowhere.\" LLMs as nodes, the graph as the runtime, and a clear contract between them.",[24,165,167],{"id":166},"what-if-the-graph-actually-behaved-like-a-network","What if the graph actually behaved like a network?",[11,169,170,171,178,179,184],{},"This is the question that motivated ",[172,173,177],"a",{"href":174,"rel":175},"https:\u002F\u002Fwanderer-flow.de\u002Fblog\u002Freactive-graph-sequencing-the-technology-behind-wanderer",[176],"nofollow","Reactive Graph Sequencing",", the engine behind Wanderer. The idea, as laid out in ",[172,180,183],{"href":181,"rel":182},"https:\u002F\u002Fwanderer-flow.de\u002Fblog\u002Fim-done-flow-editors-are-broken-and-you-all-know-it",[176],"I'm done. Flow editors are broken. And you all know it.",", is simple to state and surprisingly hard to find anywhere else.",[11,186,187],{},"Treat the graph as the runtime. Let state live in nodes. Let logic live on edges. Let the network continuously re-sequence itself as state changes. Give edges real semantic weight (must, may, not) instead of \"go here next.\" Add control edges so distant nodes can push state or call each other without violating the visual structure. Then watch what becomes possible.",[11,189,190],{},"You stop drawing diagrams. You start drawing behavior.",[24,192,194],{"id":193},"the-flows-that-suddenly-become-trivial","The flows that suddenly become trivial",[11,196,197,198,203],{},"The clearest way to understand the difference is to look at flows that are essentially impossible (or require pages of custom code) in conventional builders, and become a handful of nodes in a real network engine. Every one of the following is a working example in the ",[172,199,202],{"href":200,"rel":201},"https:\u002F\u002Fwanderer-flow.de\u002Fflows",[176],"Wanderer flow database",".",[11,205,206,209],{},[42,207,208],{},"A chatbot that keeps talking while a form is open."," \"A chatbot that helps you fill out a form\" lets the form stay visible while the bot continues reacting, sending messages, and offering guidance in the background. No frozen UI. No blocking modal. Two regions of the network alive at once.",[11,211,212,215],{},[42,213,214],{},"Automatic multi intent serialization."," A user types a single prompt containing several intentions. The flow detects them, queues them, and processes them one after another, cleanly. No restart. No \"I only understood one thing.\" The network simply activates the relevant regions and orders them.",[11,217,218,221],{},[42,219,220],{},"Automatic UI cleanup."," When a button, form, or input no longer makes sense given the current state, Wanderer removes it automatically. Because the graph already knows which nodes are alive and which are not. You never write cleanup code, because cleanup is a property of the network, not a task.",[11,223,224,227],{},[42,225,226],{},"Context change detection."," A flow that notices when a user keeps switching back and forth between two product branches, and proactively offers help. That is the network observing its own traversal history. Try wiring that with conventional condition fields.",[11,229,230,233],{},[42,231,232],{},"Product configurator with live stock invalidation."," A customer is halfway through configuring a product. The last unit sells out via an API event. The chatbot interrupts, tidies up the affected UI, explains the situation, and offers alternatives. No restart. No custom backtracking code. The state changed, the network re-sequenced, and the affected branches died on their own.",[11,235,236,239],{},[42,237,238],{},"The Time Traveling Pizza Configurator."," Pick your dough, your sauce, your toppings. Jump back. Change your mind. Break it if you can. Backtracking, follow up questions, and data invalidation all happen on their own, without a single line of code, so the configuration always stays consistent no matter how often you reshape it.",[11,241,242,245],{},[42,243,244],{},"Try and Throw for unexpected entries."," When a user types a new intention instead of, say, an expected order number, a Try \u002F Catch structure catches that signal deep in the conversation and redirects it elsewhere. Errors and surprises become routable events, not crashes.",[11,247,248],{},"None of these are demos invented to flatter the engine. They are the everyday situations that break conventional builders, expressed as a few nodes and edges because the underlying network is finally allowed to do what networks do.",[24,250,252],{"id":251},"stop-drawing-diagrams-start-drawing-systems","Stop drawing diagrams. Start drawing systems.",[11,254,255],{},"We have been staring at network graphs on our screens for twenty years and treating them like flowcharts from a 1970s textbook. The energy was always there. The structure was always there. We just kept asking it to do one tiny job: tell me what comes next.",[11,257,258],{},"Networks can do so much more. They can remember, reroute, parallelize, invalidate, and adapt. They can absorb the messiness of real users instead of pushing it back onto developers, agencies, or worst of all, the users themselves.",[11,260,261],{},"The next generation of flow builders will not win because of nicer icons or a shinier sidebar. It will win because it finally treats the graph as what it has always been. A living network. With all the power that implies.",[11,263,264],{},"We have been drawing them for two decades. It is time we started using them.",[11,266,267,268],{},"Title image: ",[172,269,270],{"href":270,"rel":271},"https:\u002F\u002Funsplash.com\u002Fde\u002Ffotos\u002Fgrunes-und-schwarzes-seil-BW0vK-FA3eg",[176],{"title":273,"searchDepth":274,"depth":274,"links":275},"",2,[276,277,278,279,280,281,282,283],{"id":26,"depth":274,"text":27},{"id":78,"depth":274,"text":79},{"id":94,"depth":274,"text":95},{"id":122,"depth":274,"text":123},{"id":150,"depth":274,"text":151},{"id":166,"depth":274,"text":167},{"id":193,"depth":274,"text":194},{"id":251,"depth":274,"text":252},"md",{"date":286,"author":287,"headerImage":288},"2026-06-11","Chris","\u002Fimages\u002Fblog\u002Fnetwork2.jpg",true,"\u002Fblog\u002Fwe-have-been-drawing-flows-for-20-years-but-we-are-not-using-their-power",{"title":6,"description":13},{"loc":290},"blog\u002Fwe-have-been-drawing-flows-for-20-years-but-we-are-not-using-their-power","S7acTZVTYLK514Eytm6du19qc7nQ-_mP-z3hN83S3jc",{"id":296,"title":183,"body":297,"description":301,"extension":284,"meta":440,"navigation":289,"path":443,"seo":444,"sitemap":445,"stem":446,"__hash__":447},"blog\u002Fblog\u002FIm-done-Flow-editors-are-broken-And-you-all-know-it.md",{"type":8,"value":298,"toc":434},[299,302,305,308,311,316,320,323,326,329,332,336,339,342,345,348,351,354,357,361,375,378,386,389,395,399,406,413,420,423,428],[11,300,301],{},"I spent the last years trying to make flow editors work. For chatbots. For forms. For LLM orchestration. Every single time I end up in the same place: buried in nested menus, drowning in node configurations, writing inline code in a tool that promised me \"no-code.\"",[11,303,304],{},"I'm done making excuses for these tools. They are broken. Not the UI. Not the docs. The foundation.",[11,306,307],{},"So you open Botpress. Or Voiceflow. Or n8n. And within five minutes you're staring at a canvas full of nodes, nested menus, inline code editors, and condition builders that feel like they need their own documentation. You wanted to build a chatbot. Now you're studying a tool.",[11,309,310],{},"And it's not just chatbots. Complex form flows, onboarding wizards, LLM orchestration. Every single flow builder out there follows the same pattern: drag a node, click on it, get buried in configuration. Add a condition? Another menu. Need an API call? Another node, another config panel. Want to change something? Good luck finding where that logic actually lives.",[11,312,313],{},[42,314,315],{},"This is not normal. And we should stop pretending it is.",[24,317,319],{"id":318},"the-code-editor-test","The code editor test",[11,321,322],{},"Let me ask you something. Have you ever clicked on a variable name in your code editor and suddenly 10 nested submenus popped open? With configuration options, conditions, and inline logic attached to that single variable?",[11,324,325],{},"No? Of course not. That would be insane. No developer would accept that. You'd close the editor and never look back.",[11,327,328],{},"So why do we accept exactly this in flow builders? Every node is a little universe of hidden complexity. Click on it, and you're three menus deep before you even understand what it does. That's not a powerful tool. That's a broken abstraction.",[11,330,331],{},"If a flow editor requires a course before you can use it, it's not a tool. It's a problem.",[24,333,335],{"id":334},"the-real-issue-is-deeper-than-ui","The real issue is deeper than UI",[11,337,338],{},"The frustrating thing is: most people blame the UI. \"It just needs a better interface.\" \"A cleaner design.\" \"Fewer options.\"",[11,340,341],{},"No. The UI is a symptom. The actual problem is the underlying architecture.",[11,343,344],{},"Think about it. An edge between two nodes is already a condition. It says: if this, then that. That's temporal logic. That's a rule. It's right there, visible on the canvas.",[11,346,347],{},"So why does every flow builder then bury another layer of conditions inside the nodes? You connect two nodes with an edge, and then you click on the node and configure more conditions in a nested menu. Conditions hidden inside a box. Invisible from the outside. Black boxes everywhere.",[11,349,350],{},"And it gets worse. Most flow builders love super-nodes. Take a typical \"Choice Node\" or \"Question Node.\" It contains the question, the answer options, the branching logic, sometimes even validation. All packed into one node. That's a conceptual breach. The answer options are not part of the graph. They are buried inside a single node, invisible to the structure, unreachable by edge logic.",[11,352,353],{},"What if each answer option was its own node? Connected by edges that already carry the logic? Then your entire decision tree would be visible on the canvas. No hidden menus. No black boxes. The graph is the logic. This applies to every complex node type out there. The moment a node contains structure that should live in the graph, you've lost the point of having a graph in the first place.",[11,355,356],{},"And there is another problem: Most flow builders are event-driven at their core. Something happens, a trigger fires, a sequence runs top to bottom, done. That model has no real concept of state. It doesn't know where you are. It doesn't adapt when things change. So every edge case, every branch, every \"what if the user goes back\" scenario has to be manually wired and configured inside the nodes. The architecture can't handle the logic on a structural level, so it dumps it on you, hidden behind click after click after click.",[24,358,360],{"id":359},"what-if-the-graph-could-think-for-itself","What if the graph could think for itself?",[11,362,363,364,367,368,367,371,374],{},"Imagine a different foundation. Instead of \"event happens, sequence runs,\" the graph itself holds the state. Every node knows if it's alive or dead. Every connection between nodes has a clear semantic meaning: this path ",[42,365,366],{},"must"," be taken, this path ",[42,369,370],{},"may",[42,372,373],{},"must not"," be taken.",[11,376,377],{},"Three edge types. Must. May. Not. That's it. And that's enough. These three types can express every logical gate visually on the canvas. AND, OR, NOT, XOR. No configuration panels. No inline code. Just edges you can see.",[11,379,380,381,385],{},"When state changes, the graph re-sequences itself. You don't manually wire fallback paths. You don't write inline conditions. The structure ",[382,383,384],"em",{},"is"," the logic. Change a decision and entire branches die while others come alive. No custom code. No nested menus. The graph adapts because it was designed to.",[11,387,388],{},"And before someone asks: no, re-sequencing doesn't mean the entire graph is traversed every time. At the start, only the entry node is active. As the user progresses, the active portion grows, but it stabilizes at a fraction of the total graph. When a user backtracks, the old branch dies and a new one activates. The traversal shifts, it doesn't accumulate. The more complex your graph, the more branches are dead at any given moment. Complexity makes it more efficient, not less.",[11,390,391,392,394],{},"This concept is called ",[42,393,177],{},". And I built a flow editor based on it.",[24,396,398],{"id":397},"wanderer","Wanderer",[11,400,401,405],{},[172,402,398],{"href":403,"rel":404},"https:\u002F\u002Fwanderer-flow.de",[176]," is an open source flow editor built on RGS. No nested menus. No inline code. No configuration hell. The graph structure itself defines the logic.",[11,407,408,409],{},"If you want to understand the technical foundation in detail, I wrote about it here: ",[172,410,412],{"href":174,"rel":411},[176],"Reactive Graph Sequencing: The Technology Behind Wanderer",[11,414,415,416],{},"Want to see demos? ",[172,417,419],{"href":200,"rel":418},[176],"Check this out",[11,421,422],{},"I'm not saying this is the only way. But I am saying that the current generation of flow builders is built on a broken foundation. And we should stop blaming ourselves for struggling with tools that were never designed to be intuitive.",[11,424,425],{},[42,426,427],{},"What do you think? Is the architecture the real problem, or am I just bad at reading nested menus?",[11,429,267,430],{},[172,431,432],{"href":432,"rel":433},"https:\u002F\u002Fpixabay.com\u002Fde\u002Fillustrations\u002Fai-generiert-scrapyard-wagen-8241457\u002F",[176],{"title":273,"searchDepth":274,"depth":274,"links":435},[436,437,438,439],{"id":318,"depth":274,"text":319},{"id":334,"depth":274,"text":335},{"id":359,"depth":274,"text":360},{"id":397,"depth":274,"text":398},{"date":441,"author":287,"headerImage":442},"2026-05-15","\u002Fimages\u002Fblog\u002Fjunk.jpg","\u002Fblog\u002Fim-done-flow-editors-are-broken-and-you-all-know-it",{"title":183,"description":301},{"loc":443},"blog\u002FIm-done-Flow-editors-are-broken-And-you-all-know-it","NmtHLgPrxFygkHT2Hccinu-6I6KqZaR10TEfZ8d6YRE",{"id":449,"title":450,"body":451,"description":455,"extension":284,"meta":699,"navigation":289,"path":702,"seo":703,"sitemap":704,"stem":705,"__hash__":706},"blog\u002Fblog\u002Fwhy-wanderer-chatbots-dont-block-and-what-that-means-in-practice.md","Why Wanderer Chatbots Don't Block and What That Means in Practice",{"type":8,"value":452,"toc":691},[453,456,463,469,473,476,479,482,486,497,500,533,536,540,543,546,566,569,573,579,582,608,611,615,621,632,635,649,656,660,667,670,673,676,685],[11,454,455],{},"Most chatbots work like forms in disguise. They ask a question, wait for your answer, then move on. It's a simple, linear, turn-based pattern. You'll find it everywhere. But it's also a fundamental limitation that rarely gets questioned.",[11,457,458,459,462],{},"Wanderer works differently. Wanderer chatbots are ",[42,460,461],{},"non-blocking",", meaning the conversation keeps moving even while interactive elements are on screen. Buttons can appear, forms can be open, timers can be running, and the bot keeps talking, reacting, and adapting in parallel.",[11,464,465,466,203],{},"This isn't a workaround. It's a direct consequence of the underlying technology: ",[42,467,468],{},"Reactive Graph Sequencing (RGS)",[24,470,472],{"id":471},"the-blocking-problem","The blocking problem",[11,474,475],{},"In a traditional chatbot builder, every interactive element acts as a roadblock. When the bot shows a set of buttons, it stops. It waits. Nothing else happens until the user clicks. The entire conversation is paused by a single UI element.",[11,477,478],{},"For simple FAQ bots, that's fine. But as soon as you want something that responds to time, to external events, or to multiple things happening at once, the blocking model breaks down.",[11,480,481],{},"In a real conversation, the other person doesn't freeze mid-sentence just because they asked you a question. They might add context, react to your body language, or change the subject entirely. Traditional chatbots can't do any of this. Wanderer can.",[24,483,485],{"id":484},"how-wanderer-stays-non-blocking","How Wanderer stays non-blocking",[11,487,488,489,492,493,496],{},"The key is how Wanderer models conversations. Instead of a linear flow that moves from step A to step B to step C, Wanderer uses a ",[42,490,491],{},"reactive graph",". Every element in the conversation (messages, buttons, input fields) is a ",[42,494,495],{},"node"," in that graph. These nodes don't wait for each other unless you explicitly tell them to.",[11,498,499],{},"In practice, that means:",[35,501,502,509,515,521,527],{},[38,503,504,505,508],{},"A ",[42,506,507],{},"question node"," can display suggestion buttons while the bot continues sending messages.",[38,510,504,511,514],{},[42,512,513],{},"form node"," with text inputs, number fields, or email fields can sit open while the graph processes other logic in the background.",[38,516,504,517,520],{},[42,518,519],{},"button node"," can fire a short event into the graph without interrupting anything else.",[38,522,504,523,526],{},[42,524,525],{},"select node"," can render a dynamic list of options from an array, and that list can update while the conversation moves on.",[38,528,504,529,532],{},[42,530,531],{},"panel node"," can display rich, interactive content using Markdown and Handlebars (live data, formatted output, embedded visuals) without halting the flow.",[11,534,535],{},"None of these elements block the graph. They participate in it.",[24,537,539],{"id":538},"a-concrete-example-the-quiz","A concrete example: the quiz",[11,541,542],{},"One of Wanderer's flow templates illustrates this well: a quiz game.",[11,544,545],{},"The bot asks a question and presents multiple-choice answers as buttons. A timer starts counting down. So far, nothing unusual. But here's where it gets interesting:",[35,547,548,554,560],{},[38,549,550,553],{},[42,551,552],{},"The 50\u002F50 joker:"," Press the joker button and two wrong answers disappear from the screen instantly, while the timer keeps running and the bot keeps talking.",[38,555,556,559],{},[42,557,558],{},"Time runs out:"," If the user doesn't answer in time, all answer buttons vanish. The bot announces that time is up. No stale buttons sitting around, no leftover UI from a previous state.",[38,561,562,565],{},[42,563,564],{},"The bot keeps talking throughout:"," While buttons appear and disappear and timers tick, the bot can still send messages. It can mention how much time is left, react to the joker being used, or comment on hesitation.",[11,567,568],{},"In a traditional chatbot builder, this would require custom code, complex workarounds, or simply wouldn't be possible. In Wanderer, it's just nodes in a graph.",[24,570,572],{"id":571},"why-this-matters-beyond-quizzes","Why this matters beyond quizzes",[11,574,575,576,203],{},"The quiz is a useful demo, but the underlying principle has broader applications. A non-blocking chatbot can react to ",[42,577,578],{},"events that don't originate from the user",[11,580,581],{},"A few examples:",[35,583,584,590,596,602],{},[38,585,586,589],{},[42,587,588],{},"E-commerce:"," A product goes out of stock while the user is configuring it. The bot reacts immediately without waiting for the user's next input.",[38,591,592,595],{},[42,593,594],{},"Customer support:"," A live agent joins the conversation. The bot adjusts seamlessly without resetting the flow.",[38,597,598,601],{},[42,599,600],{},"IoT and real-time data:"," A sensor triggers an alert. The bot notifies the user mid-conversation, regardless of what they were doing.",[38,603,604,607],{},[42,605,606],{},"Time-sensitive workflows:"," A deadline passes, a session expires, or a price changes, and the bot adapts in real time.",[11,609,610],{},"None of this works in a blocking model. There, the bot is frozen, waiting for a click that might never come while conditions change around it.",[24,612,614],{"id":613},"the-technology-reactive-graph-sequencing","The technology: Reactive Graph Sequencing",[11,616,617,618,620],{},"So how does this work under the hood? The answer is ",[42,619,468],{},", a paradigm that rethinks how chatbot logic is structured.",[11,622,623,624,627,628,631],{},"Traditional bots are ",[42,625,626],{},"event-driven",": something happens, then the bot decides what to do next. RGS is ",[42,629,630],{},"state-driven",": the graph continuously evaluates the current state of the entire conversation and determines what should be happening right now.",[11,633,634],{},"Concretely:",[35,636,637,640,643,646],{},[38,638,639],{},"Nodes can activate and deactivate based on conditions, not just user input.",[38,641,642],{},"Multiple branches of the graph can be active simultaneously.",[38,644,645],{},"UI elements appear and disappear as the state changes, with no cleanup code and no leftover artifacts.",[38,647,648],{},"The graph can re-sequence itself when conditions change.",[11,650,651,652,655],{},"All of this happens ",[42,653,654],{},"visually, in the browser, without writing code",". You connect nodes, define conditions using Must\u002FMay\u002FNot edges, and the graph handles the rest.",[24,657,659],{"id":658},"non-blocking-as-architecture-not-feature","Non-blocking as architecture, not feature",[11,661,662,663,666],{},"Most chatbot builders treat non-blocking behavior as an edge case, something you patch in when the default flow isn't enough. In Wanderer, non-blocking is the ",[42,664,665],{},"default",". It's not bolted on top; it's built into the architecture.",[11,668,669],{},"Every node is independent. Every node is reactive. Every node can respond to state changes from any source: user input, timers, external events, other nodes. The graph doesn't block because there's nothing to block. There's no single thread of execution waiting for a response. There's a graph that reacts to the world as it changes.",[11,671,672],{},"That's why Wanderer chatbots feel different. They don't wait, they don't freeze, and they don't leave stale buttons on the screen. They move with the conversation and with everything happening around it.",[674,675],"hr",{},[11,677,678],{},[382,679,680,681,203],{},"Wanderer is a visual chatbot builder powered by Reactive Graph Sequencing. Build non-blocking, reactive conversations without code. Learn more at ",[172,682,684],{"href":403,"rel":683},[176],"wanderer-flow.de",[11,686,267,687],{},[172,688,689],{"href":689,"rel":690},"https:\u002F\u002Funsplash.com\u002Fde\u002Ffotos\u002Fein-kleiner-wasserfall-mitten-im-wald-LTDMP9v21cc",[176],{"title":273,"searchDepth":274,"depth":274,"links":692},[693,694,695,696,697,698],{"id":471,"depth":274,"text":472},{"id":484,"depth":274,"text":485},{"id":538,"depth":274,"text":539},{"id":571,"depth":274,"text":572},{"id":613,"depth":274,"text":614},{"id":658,"depth":274,"text":659},{"date":700,"author":287,"headerImage":701},"2026-04-04","\u002Fimages\u002Fblog\u002Fwater.jpg","\u002Fblog\u002Fwhy-wanderer-chatbots-dont-block-and-what-that-means-in-practice",{"title":450,"description":455},{"loc":702},"blog\u002Fwhy-wanderer-chatbots-dont-block-and-what-that-means-in-practice","PHvfSjRMvM0x1KT1aAlzIfhJp-IktBhXWF7M4ot_tf8",{"id":708,"title":709,"body":710,"description":716,"extension":284,"meta":1043,"navigation":289,"path":1046,"seo":1047,"sitemap":1048,"stem":1049,"__hash__":1050},"blog\u002Fblog\u002Fconversational-try-catch-how-wanderer-handles-late-intent-switching-in-chatbots.md","Conversational Try\u002FCatch: How RGS Handles Late Intent Switching in Chatbots",{"type":8,"value":711,"toc":1025},[712,717,720,726,733,735,739,742,774,777,783,786,807,810,812,816,819,824,827,831,842,846,849,853,856,860,863,865,869,872,876,883,886,892,895,899,906,913,917,920,931,937,941,944,978,981,983,987,990,1001,1004,1009,1011,1019],[11,713,714],{},[42,715,716],{},"Most chatbot builders break when users change their mind mid-conversation. RGS makes intent switching a first-class feature",[11,718,719],{},"If you've ever built a conversational flow, you know the problem: users don't follow your script. They start asking about their order, then halfway through, they want your office address. Traditional flow builders treat this as an edge case. Reactive Graph Sequencing treats it as business as usual.",[11,721,722,723,203],{},"In this post, we'll walk through a concrete scenario (an order details chatbot) that demonstrates how RGS handles late intent switching using a pattern we call ",[42,724,725],{},"Conversational Try\u002FCatch",[11,727,728,729],{},"You can try and inspect a live example here: ",[172,730,731],{"href":731,"rel":732},"https:\u002F\u002Fwanderer-flow.de\u002Fflows\u002FCatch-unexpected-inputs-with-Try-and-Throw-nodes-lfvdiy3m25xrk68ogeras94402y46fyz",[176],[674,734],{},[24,736,738],{"id":737},"the-scenario","The Scenario",[11,740,741],{},"A customer opens a chat with your e-commerce support bot. The conversation is designed to:",[743,744,745,751,757,767],"ol",{},[38,746,747,750],{},[42,748,749],{},"A Prompt node"," captures their initial message.",[38,752,753,756],{},[42,754,755],{},"A GPT node"," receives the input, classifies the intent, and determines what the user needs.",[38,758,759,762,763,766],{},[42,760,761],{},"A Queue node"," picks up the identified intent and routes it to the appropriate ",[42,764,765],{},"Task node",", in this case, \"Order Details.\"",[38,768,769,770,773],{},"The task flow continues. A second ",[42,771,772],{},"Prompt node"," further down the conversation asks the user for their order number.",[11,775,776],{},"Simple enough. But here's where it gets interesting.",[11,778,779,780],{},"Instead of entering an order number, the user types: ",[382,781,782],{},"\"What's your address?\"",[11,784,785],{},"This has nothing to do with order tracking. In most chatbot systems, this is where things go sideways. But in RGS, this is where things get elegant.",[743,787,789,795,801,804],{"start":788},5,[38,790,504,791,794],{},[42,792,793],{},"Throw node"," attached to the order-number prompt detects that the input doesn't match expectations. It performs a clean exit and throws its state upward.",[38,796,504,797,800],{},[42,798,799],{},"Try node",", positioned before the GPT node at the top of the conversation graph, catches that thrown state.",[38,802,803],{},"The intercepted prompt (the one that couldn't be handled in the specialized order-number context) is sent back to the GPT node for re-evaluation.",[38,805,806],{},"The GPT node classifies the new intent. The Queue and Task nodes react accordingly. The conversation seamlessly pivots to answering the address question.",[11,808,809],{},"The user never notices the plumbing. The conversation just flows.",[674,811],{},[24,813,815],{"id":814},"how-traditional-chatbot-builders-handle-this","How Traditional Chatbot Builders Handle This",[11,817,818],{},"If you've worked with conventional flow builders (whether visual drag-and-drop platforms, Dialogflow-style NLU systems, or custom-coded solutions) you've likely encountered these pain points when dealing with mid-conversation intent changes:",[820,821,823],"h3",{"id":822},"_1-rigid-linear-flows","1. Rigid, Linear Flows",[11,825,826],{},"Most chatbot builders model conversations as decision trees or linear sequences. Once a user enters a branch (say, \"Order Details\"), the flow is locked in. There's no native mechanism to jump back to an earlier decision point and re-evaluate. If the user says something unexpected, the bot either asks again, shows a fallback message, or breaks entirely.",[820,828,830],{"id":829},"_2-fallback-hell","2. Fallback Hell",[11,832,833,834,837,838,841],{},"The standard approach to unexpected input is a \"fallback intent\". A catch-all that fires when nothing matches. But fallbacks are blunt instruments. They don't know ",[382,835,836],{},"where"," the user was in the conversation or ",[382,839,840],{},"what context"," was active. They can't redirect the user to a meaningful new path. At best, they say \"Sorry, I didn't understand that. Could you try again?\" At worst, they restart the entire conversation.",[820,843,845],{"id":844},"_3-global-intent-detection-as-a-band-aid","3. Global Intent Detection as a Band-Aid",[11,847,848],{},"Some platforms try to solve this with \"global intents\" (intents that can fire from anywhere in the conversation). But this creates its own problems: global intents compete with local ones, priority conflicts emerge, and the flow designer ends up managing a tangled web of overrides. The more intents you add, the more brittle the system becomes.",[820,850,852],{"id":851},"_4-manual-state-management","4. Manual State Management",[11,854,855],{},"Developers who need real intent-switching capability often resort to custom code. They store conversation state in variables, write middleware to detect out-of-scope inputs, manually rewind the flow to an earlier point, and hope the re-entry doesn't corrupt the context. This works until the conversation gets complex. Then it becomes a maintenance nightmare.",[820,857,859],{"id":858},"_5-no-retroactive-re-evaluation","5. No Retroactive Re-Evaluation",[11,861,862],{},"This is the fundamental limitation. Traditional flow builders execute forward. Once a node has run, its result is final. There's no concept of going back to a previous node, changing its state, and having everything downstream automatically recalculate. If you want to re-route a conversation, you have to explicitly code every possible re-routing path.",[674,864],{},[24,866,868],{"id":867},"why-conversational-trycatch-works-so-well-in-rgs","Why Conversational Try\u002FCatch Works So Well in RGS",[11,870,871],{},"The RGS approach to this problem isn't a workaround or a special feature bolted on top. It emerges naturally from how Reactive Graph Sequencing works at a fundamental level.",[820,873,875],{"id":874},"the-key-insight-influencing-earlier-node-states","The Key Insight: Influencing Earlier Node States",[11,877,878,879,882],{},"In RGS, every node holds state. And crucially, ",[42,880,881],{},"state can be pushed from one node to any other node in the graph",", including nodes that are earlier in the sequence. This is the superpower that makes Conversational Try\u002FCatch possible.",[11,884,885],{},"When the Throw node fires, it doesn't just emit an error signal. It pushes its state (the unhandled user input) to the Try node that sits before the GPT node at the top of the graph. This changes the Try node's state.",[11,887,888,889],{},"And here's where RGS fundamentally differs from every traditional flow builder: ",[42,890,891],{},"when a node's state changes, the entire graph re-traverses and generates a new execution sequence.",[11,893,894],{},"The graph doesn't just \"continue from where it left off.\" It re-evaluates everything. The GPT node sees the new input. The Queue and Task nodes receive the new intent classification. The entire downstream sequence recalculates. The conversation adapts.",[820,896,898],{"id":897},"its-not-exception-handling-its-re-sequencing","It's Not Exception Handling, It's Re-Sequencing",[11,900,901,902,905],{},"In traditional programming, try\u002Fcatch is about handling errors. In RGS, the Try\u002FThrow pattern is about ",[42,903,904],{},"redirecting the flow of state through the graph",". The Throw node doesn't signal \"something went wrong.\" It signals \"this input belongs somewhere else\" and it knows exactly where to send it.",[11,907,908,909,912],{},"This is possible because the throw node has access to the ",[42,910,911],{},"inherited traversal sequence",". The throw node therefore knows exactly which try node preceded it in the sequence. No manual wiring is involved. This is pure graph theory.",[820,914,916],{"id":915},"continuous-re-evaluation-not-one-shot-execution","Continuous Re-Evaluation, Not One-Shot Execution",[11,918,919],{},"Traditional flow builders are event-driven: a message arrives, the flow processes it, done. RGS is state-driven: when state changes anywhere in the graph, the entire graph re-sequences. This means:",[35,921,922,925,928],{},[38,923,924],{},"The GPT node doesn't need to \"know\" that the input was rerouted. It just processes whatever state it currently has.",[38,926,927],{},"The Queue and Task nodes don't need special \"intent changed\" logic. They simply respond to the new sequence.",[38,929,930],{},"The conversation messages recalculate automatically. Old messages that no longer apply can become invalid. New messages appear based on the current path.",[11,932,933,936],{},[42,934,935],{},"The graph continuously asks: \"Given everything we know right now, what should be happening?\""," That question is re-answered every time state changes. This is what makes late intent switching feel seamless rather than forced.",[820,938,940],{"id":939},"clean-separation-of-concerns","Clean Separation of Concerns",[11,942,943],{},"Notice how each node in this pattern has a single, clear responsibility:",[35,945,946,951,957,963,968,973],{},[38,947,948,950],{},[42,949,772],{},": Capture user input",[38,952,953,956],{},[42,954,955],{},"GPT node",": Classify intent",[38,958,959,962],{},[42,960,961],{},"Queue node",": Route to the right task",[38,964,965,967],{},[42,966,765],{},": Execute the task logic",[38,969,970,972],{},[42,971,793],{},": Signal that input doesn't belong here",[38,974,975,977],{},[42,976,799],{},": Catch rerouted input and feed it back into the classification pipeline",[11,979,980],{},"No node needs to understand the full conversation flow. No node contains special-case logic for intent switching. The behavior emerges from the graph structure and RGS's reactive re-sequencing. Add a new intent? Add a new task node. The Try\u002FThrow pattern handles the rerouting automatically.",[674,982],{},[24,984,986],{"id":985},"the-bigger-picture","The Bigger Picture",[11,988,989],{},"This order-tracking example is just one instance of a much broader capability. The Conversational Try\u002FCatch pattern works for any situation where user input might not match the current context:",[35,991,992,995,998],{},[38,993,994],{},"A user configuring a product who suddenly asks about shipping",[38,996,997],{},"A patient filling out a medical form who asks about insurance coverage",[38,999,1000],{},"A lead in a sales flow who pivots to a support question",[11,1002,1003],{},"In each case, the specialized context (product config, medical form, sales flow) can Throw the unexpected input back to a general-purpose classifier, which re-evaluates and re-routes the conversation all without losing context, without custom code, and without the user ever feeling like the bot got confused.",[11,1005,1006],{},[42,1007,1008],{},"This is what happens when intent switching isn't an edge case you handle, but a natural consequence of how your system works.",[674,1010],{},[11,1012,1013],{},[382,1014,1015,1016,203],{},"Wanderer is the first flow builder built on Reactive Graph Sequencing. Start building your own adaptive conversations at ",[172,1017,684],{"href":403,"rel":1018},[176],[11,1020,267,1021],{},[172,1022,1023],{"href":1023,"rel":1024},"https:\u002F\u002Fpixabay.com\u002Fde\u002Fphotos\u002Fbaseball-ball-handschuh-582887\u002F",[176],{"title":273,"searchDepth":274,"depth":274,"links":1026},[1027,1028,1036,1042],{"id":737,"depth":274,"text":738},{"id":814,"depth":274,"text":815,"children":1029},[1030,1032,1033,1034,1035],{"id":822,"depth":1031,"text":823},3,{"id":829,"depth":1031,"text":830},{"id":844,"depth":1031,"text":845},{"id":851,"depth":1031,"text":852},{"id":858,"depth":1031,"text":859},{"id":867,"depth":274,"text":868,"children":1037},[1038,1039,1040,1041],{"id":874,"depth":1031,"text":875},{"id":897,"depth":1031,"text":898},{"id":915,"depth":1031,"text":916},{"id":939,"depth":1031,"text":940},{"id":985,"depth":274,"text":986},{"date":1044,"author":287,"headerImage":1045},"2026-03-27","\u002Fimages\u002Fblog\u002Fcatch.jpg","\u002Fblog\u002Fconversational-try-catch-how-wanderer-handles-late-intent-switching-in-chatbots",{"title":709,"description":716},{"loc":1046},"blog\u002Fconversational-try-catch-how-wanderer-handles-late-intent-switching-in-chatbots","NSkhRAb5dufKSp64WMXc0pu4xv-nmE5sUBAgvZNLF0g",{"id":1052,"title":412,"body":1053,"description":1059,"extension":284,"meta":1634,"navigation":289,"path":1637,"seo":1638,"sitemap":1639,"stem":1640,"__hash__":1641},"blog\u002Fblog\u002Freactive-graph-sequencing-the-technology-behind-wanderer.md",{"type":8,"value":1054,"toc":1618},[1055,1060,1063,1065,1069,1072,1075,1095,1098,1105,1107,1111,1114,1117,1120,1122,1126,1133,1147,1150,1152,1156,1163,1166,1169,1183,1190,1192,1196,1199,1202,1210,1216,1219,1221,1225,1228,1231,1257,1260,1262,1266,1269,1295,1297,1301,1304,1310,1313,1334,1337,1343,1346,1349,1351,1355,1358,1390,1392,1396,1399,1431,1434,1436,1440,1574,1577,1579,1583,1586,1589,1591,1595,1598,1600,1604,1607,1610,1612],[11,1056,1057],{},[42,1058,1059],{},"Most flow builders execute your logic once and move on. RGS rebuilds the entire sequence every time your data changes.",[11,1061,1062],{},"Wanderer is a new kind of flow builder, and at its heart is a technology called RGS – Reactive Graph Sequencing. It solves a problem hiding in plain sight: workflows that need to adapt in real-time, not just react to events.",[674,1064],{},[24,1066,1068],{"id":1067},"what-is-graph-sequencing","What Is Graph Sequencing?",[11,1070,1071],{},"Graph sequencing takes a graph of nodes and edges and collapses it into a logical execution order. Which node runs after which? That's the sequencing problem.",[11,1073,1074],{},"RGS uses depth-first traversal combined with three types of directed edges:",[35,1076,1077,1083,1089],{},[38,1078,1079,1082],{},[42,1080,1081],{},"Must"," – This path must be taken",[38,1084,1085,1088],{},[42,1086,1087],{},"May"," – This path can be taken (conditional)",[38,1090,1091,1094],{},[42,1092,1093],{},"Not"," – This path must not be taken",[11,1096,1097],{},"Each edge type has a visual weight (thickness) representing its priority. With just these three primitives, you can draw any logical gate purely visually, and traversal collapses the visual representation into an executable sequence.",[11,1099,1100,1101,1104],{},"That's graph sequencing. But what makes it ",[382,1102,1103],{},"reactive","?",[674,1106],{},[24,1108,1110],{"id":1109},"the-reactive-layer-states-and-continuous-re-sequencing","The Reactive Layer: States and Continuous Re-Sequencing",[11,1112,1113],{},"Every node holds state – primitive values like booleans, strings, numbers. Outgoing edges can evaluate these states (e.g., \"is this value true?\") to determine which paths to take during traversal.",[11,1115,1116],{},"States can be pushed from one node to another via edges, partially or completely overwriting the target's state. They can also be changed by external processes – user input, API responses, database updates.",[11,1118,1119],{},"When a state changes, the graph doesn't just trigger the next node. It re-traverses the entire graph and generates a new sequence based on the updated data. The graph continuously adapts, collapsing into different execution paths as your data evolves.",[674,1121],{},[24,1123,1125],{"id":1124},"beyond-simple-flows-control-edges","Beyond Simple Flows: Control Edges",[11,1127,1128,1129,1132],{},"Traditional flow builders connect nodes linearly or with branches. RGS adds ",[42,1130,1131],{},"control edges"," that operate outside the main traversal:",[35,1134,1135,1141],{},[38,1136,1137,1140],{},[42,1138,1139],{},"Push"," – Send state to a distant node without traversing there",[38,1142,1143,1146],{},[42,1144,1145],{},"Call"," – Call logic in a remote part of the graph that causes states to change.",[11,1148,1149],{},"These enable non-local state manipulation, allowing flows that would require complex custom code in other tools.",[674,1151],{},[24,1153,1155],{"id":1154},"but-does-it-scale","But Does It Scale?",[11,1157,1158,1159,1162],{},"A question I get a lot: ",[382,1160,1161],{},"but does it scale to 1,000 nodes and beyond?"," And my honest answer is: when was the last time you actually needed a conversational flow with 1,000 nodes? Most real-world flows – onboarding wizards, configurators, support bots, approval processes – live comfortably in the tens to low hundreds. The \"scale\" concern is usually imported from backend thinking, where 1,000 of anything is small. Interactive flows are a different beast: every node is a moment a human or system actually passes through.",[11,1164,1165],{},"But let's take the question seriously anyway. If the graph re-sequences on every state change, doesn't traversal become expensive?",[11,1167,1168],{},"It doesn't – by design. At the start, only the entry node is active, so traversal is minimal. As the user progresses, active branches grow, but never into the full graph. Every decision activates one path and kills others. The active traversal rises and then stabilizes. When a user backtracks, the previously active branch dies and a new one takes its place – the traversal shifts rather than accumulates. The active portion is always a fraction of the whole.",[11,1170,1171,1172,1175,1176,1179,1180,1182],{},"There's also a second kind of scaling that matters more than node count: ",[42,1173,1174],{},"logic scaling",". In a traditional flow builder, every backtrack, every \"what if the user changes their mind three steps ago,\" every invalidation rule is code ",[382,1177,1178],{},"you"," have to write. The graph grows linearly, but the logic glueing it together grows combinatorially. RGS absorbs that work. Backtracking, invalidation, re-routing on state change – the graph handles it because that's what re-sequencing ",[382,1181,384],{},". You don't write the logic; you just change a state, and the traversal figures out the rest.",[11,1184,1185,1186,1189],{},"So the practical answer is: RGS scales fine for the flows people actually build, and more importantly, it scales ",[382,1187,1188],{},"down"," the amount of logic you have to maintain as the flow grows.",[674,1191],{},[24,1193,1195],{"id":1194},"a-concrete-example-the-adaptive-chatbot","A Concrete Example: The Adaptive Chatbot",[11,1197,1198],{},"Imagine a chatbot for an e-commerce store. A customer is configuring a custom skateboard deck and has answered five questions about graphics, size, and wheels. Then an API call comes in: the deck just went out of stock.",[11,1200,1201],{},"In a traditional flow builder, you'd have to store the conversation state, manually interrupt the flow, write custom backtracking logic, and hope you didn't break anything.",[11,1203,1204,1205,1209],{},"With RGS, you simply change a state value (",[1206,1207,1208],"code",{},"deckInStock: false","). The graph re-sequences itself. Questions based on that deck become invalid, the traversal recalculates, and a new message appears:",[1211,1212,1213],"blockquote",{},[11,1214,1215],{},"\"Sorry, the skateboard deck you're configuring just went out of stock. Can I help you with something else?\"",[11,1217,1218],{},"This isn't a special case handled by custom code – it's how RGS works by default. The graph can invalidate earlier decisions and re-route the conversation based on new information.",[674,1220],{},[24,1222,1224],{"id":1223},"why-this-matters-real-time-adaptation-vs-event-reaction","Why This Matters: Real-Time Adaptation vs. Event Reaction",[11,1226,1227],{},"Most automation tools are event-driven: something happens → trigger a workflow → execute a sequence → done.",[11,1229,1230],{},"RGS is state-driven: the graph continuously evaluates current state and generates the appropriate sequence. When state changes, the sequence changes. This enables new categories of workflows:",[35,1232,1233,1239,1245,1251],{},[38,1234,1235,1238],{},[42,1236,1237],{},"Adaptive onboarding"," that adjusts to verification failures or changed user data",[38,1240,1241,1244],{},[42,1242,1243],{},"Product configurators"," that recalculate when options become unavailable",[38,1246,1247,1250],{},[42,1248,1249],{},"Multi-stakeholder approvals"," that re-route when budget or requirements change mid-flight",[38,1252,1253,1256],{},[42,1254,1255],{},"Real-time assistants"," that respond to external events (package delivered, meeting rescheduled) and adjust the conversation",[11,1258,1259],{},"These are either impossible or require significant custom code elsewhere. With RGS, they're just graphs.",[674,1261],{},[24,1263,1265],{"id":1264},"building-wanderer-design-principles","Building Wanderer: Design Principles",[11,1267,1268],{},"Wanderer is the first implementation of RGS, built on a few unconventional principles:",[35,1270,1271,1277,1283,1289],{},[38,1272,1273,1276],{},[42,1274,1275],{},"Zero friction",": No login, no registration, no server. Open the browser and start building.",[38,1278,1279,1282],{},[42,1280,1281],{},"Immediate feedback",": Edges animate during traversal, active nodes get an outline, and clicking any node reveals its current state. The complexity of sequencing becomes tangible through visualization.",[38,1284,1285,1288],{},[42,1286,1287],{},"Self-contained learning",": Tutorials run inside the builder. Nodes load interactive guides. A chat assistant (itself built with message nodes) guides you through concepts. The graph teaches you how to build graphs.",[38,1290,1291,1294],{},[42,1292,1293],{},"Graphs are JSON",": Export, version control, share, restore. No proprietary format, no lock-in.",[674,1296],{},[24,1298,1300],{"id":1299},"but-wait-theres-still-code-in-the-nodes","But Wait — There's Still Code in the Nodes!",[11,1302,1303],{},"Yes. And that's the point. Where is the no-code promise then?",[11,1305,1306,1307,203],{},"A typical \"Send Message\" node contains code that talks to an API, formats a string, handles a timeout. That code has to exist somewhere – something has to actually do the thing. My claim isn't that code disappears. It's that code disappears from the ",[382,1308,1309],{},"control flow layer",[11,1311,1312],{},"Two very different kinds of code live in a typical flow builder:",[35,1314,1315,1321],{},[38,1316,1317,1320],{},[42,1318,1319],{},"Action code",": \"Send this HTTP request.\" \"Format this string.\" \"Write to this database.\" A side effect that talks to the outside world.",[38,1322,1323,1326,1327,1330,1331,1333],{},[42,1324,1325],{},"Control flow code",": \"If the user said yes ",[382,1328,1329],{},"and"," their cart isn't empty ",[382,1332,1329],{}," we haven't shown this question before, go to node C.\" Logic about the flow itself.",[11,1335,1336],{},"In every flow builder I know, both kinds are mixed together – buried inside nodes, hidden in condition fields, scattered across expression strings. The graph shows the choreography; the actual logic lives in a hundred little fragments you have to click into to read.",[11,1338,1339,1340,1342],{},"In RGS, control flow code is gone. The graph ",[382,1341,384],{}," the control flow. State lives in nodes. Conditions live on edges, visually. AND, OR, NOT, XOR — you draw them. If you want to know why the flow went left instead of right, look at the canvas, not a config panel.",[11,1344,1345],{},"Action code stays. A node that sends an email has to know how to send an email. But that's a capsule – a clean, reusable adapter to the outside world. It doesn't know anything about your flow; it just does its job when the graph tells it to.",[11,1347,1348],{},"That's the trade: honest about action code, ruthless about control flow code. Most \"no-code\" tools get this backwards – they hide action code behind nice icons and then ask you to write control flow code in tiny text fields. That's exactly the wrong way around.",[674,1350],{},[24,1352,1354],{"id":1353},"what-you-can-build-with-rgs","What You Can Build With RGS",[11,1356,1357],{},"Because RGS handles both forward sequencing (what happens next) and retroactive adaptation (what should have happened), it opens up use cases that other tools struggle with:",[35,1359,1360,1366,1372,1378,1384],{},[38,1361,1362,1365],{},[42,1363,1364],{},"Conversational AI with memory and context manipulation"," – chatbots that revise earlier questions, invalidate assumptions, and re-route based on real-time data",[38,1367,1368,1371],{},[42,1369,1370],{},"Dynamic product configurators"," – adapt when inventory changes, prices update, or compatibility rules shift",[38,1373,1374,1377],{},[42,1375,1376],{},"Complex approval workflows"," – multi-stage processes that re-route when stakeholders, budgets, or requirements change",[38,1379,1380,1383],{},[42,1381,1382],{},"Adaptive onboarding and wizards"," – user journeys that adjust based on verification, preferences, or external state",[38,1385,1386,1389],{},[42,1387,1388],{},"Real-time decision engines"," – business rule systems that continuously re-evaluate as conditions change",[674,1391],{},[24,1393,1395],{"id":1394},"where-rgs-sits-in-the-landscape","Where RGS Sits in the Landscape",[11,1397,1398],{},"State-driven graphs aren't new. Reactive programming, statecharts, dataflow languages — smart people have thought about this for decades. Let me be honest about where RGS borrows and where it does something different.",[35,1400,1401,1407,1413,1419,1425],{},[38,1402,1403,1406],{},[42,1404,1405],{},"Statecharts (Harel, XState)",": State machines on steroids – hierarchical state, parallel regions, beautiful transitions. Fantastic if you're a developer, but it's a library. You write JSON or TypeScript. A domain expert can't open XState and click together a pizza configurator.",[38,1408,1409,1412],{},[42,1410,1411],{},"Temporal, Cadence, durable workflow engines",": Brilliant for long-running backend processes with replay and fault tolerance. Code-first. Different problem entirely.",[38,1414,1415,1418],{},[42,1416,1417],{},"Node-RED",": The closest spiritual cousin to Wanderer – visual, graph-based, a real editor. But it's message-passing: a message flows through the graph, gets transformed, exits. There's no concept of \"this node is alive right now because the current state says so.\" When a user backtracks or a data source invalidates, you wire that yourself.",[38,1420,1421,1424],{},[42,1422,1423],{},"BPMN \u002F Camunda",": Formally founded, visual, mature. Built for long-running business processes, not interactive flows that re-evaluate continuously.",[38,1426,1427,1430],{},[42,1428,1429],{},"Reactive frameworks (Svelte, Solid, MobX signals)",": Continuous re-evaluation is their core idea, and RGS owes them conceptually. But these are code primitives. You don't draw signals on a canvas.",[11,1432,1433],{},"So what's actually new about RGS? Not any single ingredient – it's the combination: a visual editor where state lives in nodes, logic lives in edges, and the whole graph continuously re-sequences itself, in a tool a non-programmer can actually open and use. Statecharts gave us hierarchical state. Signals gave us continuous reactivity. Node-RED gave us a usable visual editor. RGS pulls those threads together and asks: what if the canvas itself was the runtime?",[674,1435],{},[24,1437,1439],{"id":1438},"the-technical-foundation-what-makes-rgs-different","The Technical Foundation: What Makes RGS Different",[1441,1442,1443,1475],"table",{},[1444,1445,1446],"thead",{},[1447,1448,1449,1455,1460,1465,1470],"tr",{},[1450,1451,1452],"th",{},[42,1453,1454],{},"Capability",[1450,1456,1457],{},[42,1458,1459],{},"RGS",[1450,1461,1462],{},[42,1463,1464],{},"Traditional Flow Builders",[1450,1466,1467],{},[42,1468,1469],{},"State Machines",[1450,1471,1472],{},[42,1473,1474],{},"Dataflow Languages",[1476,1477,1478,1498,1517,1536,1555],"tbody",{},[1447,1479,1480,1486,1489,1492,1495],{},[1481,1482,1483],"td",{},[42,1484,1485],{},"Retroactive re-sequencing",[1481,1487,1488],{},"✅ Native",[1481,1490,1491],{},"❌ Not possible",[1481,1493,1494],{},"⚠️ Limited (state transitions only)",[1481,1496,1497],{},"❌ Forward-only",[1447,1499,1500,1505,1508,1511,1514],{},[1481,1501,1502],{},[42,1503,1504],{},"Visual logic gates",[1481,1506,1507],{},"✅ Three edge types + priority",[1481,1509,1510],{},"⚠️ Basic branching",[1481,1512,1513],{},"❌ Code-based",[1481,1515,1516],{},"⚠️ Data connections",[1447,1518,1519,1524,1527,1530,1533],{},[1481,1520,1521],{},[42,1522,1523],{},"Non-local state manipulation",[1481,1525,1526],{},"✅ Push\u002FPull\u002FCall edges",[1481,1528,1529],{},"❌ Linear only",[1481,1531,1532],{},"❌ Local state",[1481,1534,1535],{},"⚠️ Limited",[1447,1537,1538,1543,1546,1549,1552],{},[1481,1539,1540],{},[42,1541,1542],{},"Continuous re-evaluation",[1481,1544,1545],{},"✅ Automatic",[1481,1547,1548],{},"❌ Event-triggered",[1481,1550,1551],{},"⚠️ Transition-based",[1481,1553,1554],{},"✅ Reactive",[1447,1556,1557,1562,1565,1568,1571],{},[1481,1558,1559],{},[42,1560,1561],{},"No server required",[1481,1563,1564],{},"✅ Pure frontend",[1481,1566,1567],{},"❌ Cloud-based",[1481,1569,1570],{},"✅ Can be local",[1481,1572,1573],{},"⚠️ Varies",[11,1575,1576],{},"RGS combines the visual simplicity of flow builders with the power of reactive programming and the expressiveness of state machines – without requiring a backend.",[674,1578],{},[24,1580,1582],{"id":1581},"why-now","Why Now?",[11,1584,1585],{},"Visual programming has been \"almost there\" for decades. Flow builders handle simple automation well but break down when workflows need to adapt dynamically.",[11,1587,1588],{},"RGS bridges that gap. It gives you the expressiveness of code with the clarity of visual diagrams, and it handles complexity without requiring you to write complex logic. Most importantly, it makes reactive, adaptive workflows accessible – not just to developers who can write custom state management code, but to anyone who can draw a graph.",[674,1590],{},[24,1592,1594],{"id":1593},"try-it-yourself","Try It Yourself",[11,1596,1597],{},"Wanderer is live and free to use. No signup, no installation. Open your browser, start building, and watch your graph come to life. See edges animate as the graph traverses. Watch nodes light up when they're active. Click any node to inspect its state in real-time. The complexity of Reactive Graph Sequencing becomes intuitive when you can see it happen.",[674,1599],{},[24,1601,1603],{"id":1602},"conclusion","Conclusion",[11,1605,1606],{},"Reactive Graph Sequencing isn't just a new algorithm – it's a new way of thinking about workflows. Instead of asking \"what happens next?\", RGS asks \"what should be happening right now, given everything we know?\"",[11,1608,1609],{},"That subtle shift unlocks workflows that adapt, reconsider, and optimize themselves in real-time. Wanderer is the first tool built on this foundation, but RGS is bigger than any single implementation. It's a technology for building systems that think in graphs and react to reality.",[674,1611],{},[11,1613,267,1614],{},[172,1615,1616],{"href":1616,"rel":1617},"https:\u002F\u002Funsplash.com\u002Fde\u002Ffotos\u002Fflachwinkelfotografie-von-metallstrukturen-ZiQkhI7417A",[176],{"title":273,"searchDepth":274,"depth":274,"links":1619},[1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633],{"id":1067,"depth":274,"text":1068},{"id":1109,"depth":274,"text":1110},{"id":1124,"depth":274,"text":1125},{"id":1154,"depth":274,"text":1155},{"id":1194,"depth":274,"text":1195},{"id":1223,"depth":274,"text":1224},{"id":1264,"depth":274,"text":1265},{"id":1299,"depth":274,"text":1300},{"id":1353,"depth":274,"text":1354},{"id":1394,"depth":274,"text":1395},{"id":1438,"depth":274,"text":1439},{"id":1581,"depth":274,"text":1582},{"id":1593,"depth":274,"text":1594},{"id":1602,"depth":274,"text":1603},{"date":1635,"author":287,"headerImage":1636},"2026-03-12","\u002Fimages\u002Fblog\u002Fnetwork.jpg","\u002Fblog\u002Freactive-graph-sequencing-the-technology-behind-wanderer",{"title":412,"description":1059},{"loc":1637},"blog\u002Freactive-graph-sequencing-the-technology-behind-wanderer","Yh7xNhH1ZI3Hx8ibWvaVUt44m0G5_cLRgnAfV7FpR28",{"id":1643,"title":1644,"body":1645,"description":1649,"extension":284,"meta":2004,"navigation":289,"path":2007,"seo":2008,"sitemap":2009,"stem":2010,"__hash__":2011},"blog\u002Fblog\u002Fwhy-a-conversation-does-not-fit-into-a-graph.md","Why a Conversation Doesn’t Fit Into a Graph",{"type":8,"value":1646,"toc":1995},[1647,1650,1653,1668,1671,1675,1682,1699,1702,1705,1715,1718,1722,1725,1731,1734,1743,1753,1756,1763,1767,1770,1773,1790,1793,1796,1807,1812,1815,1832,1835,1839,1842,1860,1863,1877,1880,1883,1886,1896,1899,1903,1906,1909,1923,1926,1936,1943,1947,1950,1967,1971,1974,1977,1980,1986,1989],[11,1648,1649],{},"Flow builders love graphs. Circles or boxes and arrows look like clarity: a clean structure, a traceable path, a promise that conversation is something you can “wire up” once and then run.",[11,1651,1652],{},"But a real conversation doesn’t live in a graph.",[11,1654,1655,1656,1659,1660,1663,1664,1667],{},"You can model it ",[382,1657,1658],{},"as"," a graph, sure. Yet the moment you try to capture what makes a conversation feel alive (revisions, interruptions, late-breaking facts, and changed minds) you discover the missing axis: ",[42,1661,1662],{},"time",". And once time becomes a first-class citizen, your neat 2D diagram quietly turns into something else: a ",[42,1665,1666],{},"four-dimensional system"," where the “shape” of the conversation depends on continuous re-evaluation, not a single traversal.",[11,1669,1670],{},"This is why a conversation doesn’t fit into a graph.",[24,1672,1674],{"id":1673},"graphs-are-great-until-you-treat-them-like-history","Graphs are great until you treat them like history",[11,1676,1677,1678,1681],{},"Most chatbots and flow builders treat a conversation like a ",[42,1679,1680],{},"committed path",":",[35,1683,1684,1687,1690,1693,1696],{},[38,1685,1686],{},"You ask a question.",[38,1688,1689],{},"The user answers.",[38,1691,1692],{},"You move forward.",[38,1694,1695],{},"Previous steps are “done,” effectively frozen.",[38,1697,1698],{},"The graph is traversed, and the conversation becomes a recorded route through it.",[11,1700,1701],{},"That works for scripted funnels. It works when the world is stable and the user never revisits earlier assumptions.",[11,1703,1704],{},"But it breaks down the moment the world behaves like the world:\ninventory changes, eligibility changes, a parallel process finishes late, the user edits an earlier answer, a policy update arrives, a payment fails, a shipping option disappears, or a previously valid suggestion becomes invalid.",[11,1706,1707,1708,1711,1712,203],{},"In real conversations, earlier statements aren’t just ",[382,1709,1710],{},"past",", they remain ",[382,1713,1714],{},"active premises",[11,1716,1717],{},"A committed flow confuses “what happened” with “what is still true.”",[24,1719,1721],{"id":1720},"the-missing-dimension-re-evaluation","The missing dimension: re-evaluation",[11,1723,1724],{},"A static graph can describe dependencies: edges carry information, nodes transform it. That’s useful.",[11,1726,1727,1728,203],{},"But conversational reality requires something stronger than dependency structure: it requires ",[42,1729,1730],{},"temporal re-evaluation",[11,1732,1733],{},"In other words:",[1211,1735,1736],{},[11,1737,1738,1739,1742],{},"A conversation is not a path through a graph.",[1740,1741],"br",{},"\nIt’s a graph whose meaning changes over time.",[11,1744,1745,1746,1749,1750,203],{},"When you introduce a system that ",[42,1747,1748],{},"ticks"," (re-runs evaluation whenever node state changes) you stop treating the graph as a one-time map and start treating it as a ",[42,1751,1752],{},"living model",[11,1754,1755],{},"Each tick is a moment in time. Each re-evaluation is a new “slice” of the conversation’s state. Stack those slices and you don’t have a 2D diagram anymore. You have a timeline of graph-states — a structure that behaves less like a flowchart and more like a simulation.",[11,1757,1758,1759,1762],{},"That’s the fourth dimension: not the graph itself, but the ",[42,1760,1761],{},"sequence of graph states"," the user experiences.",[24,1764,1766],{"id":1765},"why-late-revisions-are-the-real-test","Why “late revisions” are the real test",[11,1768,1769],{},"The most human thing a conversation can do is revise itself.",[11,1771,1772],{},"Not just “oops, let’s correct that,” but revision with consequences:",[35,1774,1775,1778,1781,1784,1787],{},[38,1776,1777],{},"An early answer is edited.",[38,1779,1780],{},"The branch you’re currently in becomes inconsistent.",[38,1782,1783],{},"Suggestions you were about to click become invalid.",[38,1785,1786],{},"A whole sub-context collapses or transforms.",[38,1788,1789],{},"Later, new information arrives and the context restores itself.",[11,1791,1792],{},"This is what most systems can’t do because they treat earlier nodes as committed milestones. Once a branch is entered, it becomes a mini-universe that assumes its premises will never change.",[11,1794,1795],{},"But in real conversations, premises change all the time.",[11,1797,1798,1799,1802,1803,1806],{},"If you build a system where ",[42,1800,1801],{},"already-processed nodes can change state",", and where ",[42,1804,1805],{},"edges can feed new information into nodes even after they were processed",", you unlock a capability that feels startlingly natural:",[1211,1808,1809],{},[11,1810,1811],{},"The past can change the present.",[11,1813,1814],{},"That sounds paradoxical until you realize it’s how people talk. We constantly reframe.",[35,1816,1817,1820,1823,1826,1829],{},[38,1818,1819],{},"“Actually, I meant the other model.”",[38,1821,1822],{},"“Wait, I’m not available on Friday.”",[38,1824,1825],{},"“I just got a message: that item is out of stock.”",[38,1827,1828],{},"“I changed my mind. Let’s do the cheaper option.”",[38,1830,1831],{},"“New info: that’s not allowed anymore.”",[11,1833,1834],{},"Human conversation isn’t turn-based truth accumulation. It’s a continuous negotiation of a shared, shifting state.",[24,1836,1838],{"id":1837},"why-a-tick-based-graph-feels-fluid","Why a tick-based graph feels “fluid”",[11,1840,1841],{},"A tick-based conversational graph is closer to reactive UI than to a script:",[35,1843,1844,1847,1850,1853],{},[38,1845,1846],{},"Nodes can compute derived state.",[38,1848,1849],{},"Events can arrive asynchronously.",[38,1851,1852],{},"The system re-evaluates when inputs change.",[38,1854,1855,1856,1859],{},"The visible conversation becomes a ",[382,1857,1858],{},"projection"," of current state, not a fixed transcript.",[11,1861,1862],{},"This is the key difference:",[35,1864,1865,1871],{},[38,1866,1867,1870],{},[42,1868,1869],{},"Classic flow:"," conversation as a log of committed steps.",[38,1872,1873,1876],{},[42,1874,1875],{},"Tick graph:"," conversation as a live view of a stateful world.",[11,1878,1879],{},"The “fluidity” comes from the fact that the system doesn’t wait for the user to speak to update reality. It updates whenever reality updates.",[11,1881,1882],{},"That makes it uniquely capable of handling situations like an online shop configuration:",[11,1884,1885],{},"You’re building a skateboard setup. Midway through, availability updates: the deck is out of stock. In a committed flow, you either ignore the truth until later, or you awkwardly inject an apology message and hope the user manually backtracks.",[11,1887,1888,1889,1892,1893,203],{},"In a tick-based system, that branch simply becomes invalid—",[382,1890,1891],{},"because it is invalid",". If the deck comes back in stock, the context can restore itself—",[382,1894,1895],{},"because it’s valid again",[11,1897,1898],{},"It’s not just responsive. It’s coherent.",[24,1900,1902],{"id":1901},"a-graph-can-model-itbut-only-if-you-admit-its-not-just-a-graph","“A graph can model it”—but only if you admit it’s not just a graph",[11,1904,1905],{},"At this point, someone will say: “Fine, but you can still represent that with a graph.”",[11,1907,1908],{},"Yes. But the important part isn’t that you can draw nodes and edges. The important part is the semantics:",[35,1910,1911,1914,1917,1920],{},[38,1912,1913],{},"nodes aren’t one-time executed steps",[38,1915,1916],{},"edges aren’t just routing; they’re dependency links",[38,1918,1919],{},"“processed” doesn’t mean “final”",[38,1921,1922],{},"evaluation is not a traversal; it’s a continuous re-evaluation driven by change",[11,1924,1925],{},"Once you do that, you’re no longer building a flowchart. You’re building a reactive system that happens to have a graph-shaped topology.",[11,1927,1928,1929,1932,1933,203],{},"The graph is the ",[382,1930,1931],{},"wiring",". The conversation is the ",[382,1934,1935],{},"animation over time",[11,1937,1938,1939,1942],{},"That’s why the title is true: a conversation doesn’t fit into a graph. Because the thing you care about isn’t the graph, it’s the ",[42,1940,1941],{},"time-evolving state"," produced by repeatedly re-running it.",[24,1944,1946],{"id":1945},"why-this-is-closer-to-real-conversations","Why this is closer to real conversations",[11,1948,1949],{},"This approach is, in my view, closer to how real conversations work:",[35,1951,1952,1955,1958,1961,1964],{},[38,1953,1954],{},"we revise earlier assumptions",[38,1956,1957],{},"we invalidate options when new information arrives",[38,1959,1960],{},"we jump contexts without ceremony",[38,1962,1963],{},"we maintain multiple threads in parallel",[38,1965,1966],{},"we adapt continuously, not sequentially",[24,1968,1970],{"id":1969},"conclusion-a-conversation-is-continuous-re-evaluation","Conclusion: A conversation is continuous re-evaluation",[11,1972,1973],{},"A conversation isn’t a path you traverse. It’s a state you keep renegotiating.",[11,1975,1976],{},"If you want a conversational system that feels genuinely alive (one that can revise early information, collapse invalid contexts, restore them when the world changes, and do it without waiting for the user to “take a turn”) you need to stop pretending the graph is the conversation.",[11,1978,1979],{},"The graph is just the topology.",[11,1981,1982,1983,203],{},"The conversation is what happens when that topology is ",[42,1984,1985],{},"re-evaluated over time",[11,1987,1988],{},"And that’s why a conversation doesn’t fit into a graph—until you let the graph tick.",[11,1990,267,1991],{},[172,1992,1993],{"href":1993,"rel":1994},"https:\u002F\u002Fpixabay.com\u002Fde\u002Fvectors\u002Fgraph-diagramm-saiten-verbindung-5727061\u002F",[176],{"title":273,"searchDepth":274,"depth":274,"links":1996},[1997,1998,1999,2000,2001,2002,2003],{"id":1673,"depth":274,"text":1674},{"id":1720,"depth":274,"text":1721},{"id":1765,"depth":274,"text":1766},{"id":1837,"depth":274,"text":1838},{"id":1901,"depth":274,"text":1902},{"id":1945,"depth":274,"text":1946},{"id":1969,"depth":274,"text":1970},{"date":2005,"author":287,"headerImage":2006},"2026-03-10","\u002Fimages\u002Fblog\u002Fgraph.jpg","\u002Fblog\u002Fwhy-a-conversation-does-not-fit-into-a-graph",{"title":1644,"description":1649},{"loc":2007},"blog\u002Fwhy-a-conversation-does-not-fit-into-a-graph","BxVLUFIbZcEfOobOQtmAf0MZtKLUDxA_FRZaJ0FoooQ",{"id":2013,"title":2014,"body":2015,"description":273,"extension":284,"meta":2497,"navigation":289,"path":2500,"seo":2501,"sitemap":2502,"stem":2503,"__hash__":2504},"blog\u002Fblog\u002Fvisual-logic-without-code-can-this-change-the-way-we-build-flow-based-systems.md","Visual Logic Without Code - Can This Change the Way We Build Flow-Based Systems?",{"type":8,"value":2016,"toc":2486},[2017,2032,2049,2051,2055,2062,2077,2080,2091,2098,2100,2104,2107,2117,2120,2161,2167,2169,2173,2180,2228,2235,2237,2241,2312,2315,2317,2321,2324,2357,2360,2380,2383,2385,2389,2392,2403,2406,2416,2422,2424,2428,2445,2452,2454,2458,2461,2466,2476,2479],[1211,2018,2019],{},[11,2020,2021,2022,1104,2025,2027,2028,2031],{},"What if logical structures weren’t just part of a flow - but ",[42,2023,2024],{},"the flow itself",[1740,2026],{},"\nWhat if you could build functional logic ",[42,2029,2030],{},"visually",", with no hidden code at all?",[11,2033,2034,2035,2037,2038,2040,2041,2044,2045,2048],{},"With ",[42,2036,398],{},", I’ve built a tool that explores exactly that idea.",[1740,2039],{},"\nIt’s a new approach to flow-based programming: where structure ",[42,2042,2043],{},"is logic",", and logic ",[42,2046,2047],{},"is executable"," - right in the browser.",[674,2050],{},[24,2052,2054],{"id":2053},"what-makes-wanderer-different","What Makes Wanderer Different?",[11,2056,2057,2058,2061],{},"There are many no-code platforms out there. But almost all of them rely on ",[42,2059,2060],{},"hidden logic"," behind visual blocks:",[35,2063,2064,2071,2074],{},[38,2065,2066,2067,2070],{},"Embedded ",[1206,2068,2069],{},"if-else"," conditions",[38,2072,2073],{},"Hidden functions",[38,2075,2076],{},"Code-like config panels",[11,2078,2079],{},"Wanderer turns that upside down.",[1211,2081,2082],{},[11,2083,2084,2085,203,2088,2090],{},"In Wanderer, ",[42,2086,2087],{},"edges are the logic",[1740,2089],{},"\nYou don’t write logic – you build it.",[11,2092,2093,2094,2097],{},"And when you're done, the graph ",[42,2095,2096],{},"executes itself",", in real time, in your browser.",[674,2099],{},[820,2101,2103],{"id":2102},"wait-arent-edge-conditions-just-code","“Wait - aren’t edge conditions just code?”",[11,2105,2106],{},"Good question - and a fair one.",[11,2108,2109,2110,2113,2114,203],{},"Wanderer ",[42,2111,2112],{},"does"," allow for tiny condition checks on edges - for example, an edge might check whether a connected switch node is ",[1206,2115,2116],{},"\"on\"",[11,2118,2119],{},"But here’s the key difference:",[35,2121,2122,2136,2148],{},[38,2123,2124,2125,2128,2129,2132,2133],{},"There are ",[42,2126,2127],{},"no function bodies",", ",[42,2130,2131],{},"no branching logic",", and ",[42,2134,2135],{},"no hidden code paths",[38,2137,2138,2139,2128,2142,2132,2145],{},"Edge conditions are always ",[42,2140,2141],{},"simple",[42,2143,2144],{},"explicit",[42,2146,2147],{},"local",[38,2149,2150,2151,1681,2154,2156,2157,2160],{},"The ",[42,2152,2153],{},"logic lives entirely in the structure",[1740,2155],{},"\nYou can ",[382,2158,2159],{},"see"," every decision - and understand it at a glance",[11,2162,2163,2164,203],{},"It’s not about hiding complexity - it’s about ",[42,2165,2166],{},"structuring it visually",[674,2168],{},[24,2170,2172],{"id":2171},"logic-as-structure-visual-gates","Logic as Structure: Visual Gates",[11,2174,2175,2176,2179],{},"To demonstrate how powerful this model can be, I built ",[42,2177,2178],{},"five fundamental logic gates"," – entirely visual, fully working, and 100% no-code.",[743,2181,2182,2192,2201,2210,2219],{},[38,2183,2184],{},[172,2185,2188,2191],{"href":2186,"rel":2187},"https:\u002F\u002Fwanderer-flow.de\u002Fbuilder?flowUrl=https:\u002F\u002Fhub.wanderer-flow.de\u002Fflows\u002Fu4ne9rzq88dgp04non88ksb5q399n4sl",[176],[42,2189,2190],{},"AND Gate"," - Try live demo",[38,2193,2194],{},[172,2195,2198,2191],{"href":2196,"rel":2197},"https:\u002F\u002Fwanderer-flow.de\u002Fbuilder?flowUrl=https:\u002F\u002Fhub.wanderer-flow.de\u002Fflows\u002Fkeevhyvfot4wbyzo60wd1vjamwdh2zag",[176],[42,2199,2200],{},"OR Gate",[38,2202,2203],{},[172,2204,2207,2191],{"href":2205,"rel":2206},"https:\u002F\u002Fwanderer-flow.de\u002Fbuilder?flowUrl=https:\u002F\u002Fhub.wanderer-flow.de\u002Fflows\u002Fmbo9idv868f1a8gz6egm1y9d42jedbc4",[176],[42,2208,2209],{},"NOT Gate",[38,2211,2212],{},[172,2213,2216,2191],{"href":2214,"rel":2215},"https:\u002F\u002Fwanderer-flow.de\u002Fbuilder?flowUrl=https:\u002F\u002Fhub.wanderer-flow.de\u002Fflows\u002F20l4vo9at74nsveaxlzgauppccjejb2x",[176],[42,2217,2218],{},"XOR Gate",[38,2220,2221],{},[172,2222,2225,2191],{"href":2223,"rel":2224},"https:\u002F\u002Fwanderer-flow.de\u002Fbuilder?flowUrl=https:\u002F\u002Fhub.wanderer-flow.de\u002Fflows\u002Fyoszf2oaib40th368srvrpcb7o0zm1ep",[176],[42,2226,2227],{},"NAND Gate",[11,2229,2230,2231,2234],{},"You can ",[42,2232,2233],{},"toggle inputs"," using switch nodes - and observe how the graph reacts in real time.",[674,2236],{},[24,2238,2240],{"id":2239},"whats-special-about-each-gate","What’s Special About Each Gate?",[1441,2242,2243,2253],{},[1444,2244,2245],{},[1447,2246,2247,2250],{},[1450,2248,2249],{},"Gate Type",[1450,2251,2252],{},"What You’ll See in the Flow",[1476,2254,2255,2265,2275,2288,2302],{},[1447,2256,2257,2262],{},[1481,2258,2259],{},[42,2260,2261],{},"AND",[1481,2263,2264],{},"All switches must be ON to activate the output node",[1447,2266,2267,2272],{},[1481,2268,2269],{},[42,2270,2271],{},"OR",[1481,2273,2274],{},"Any one (or more) switches can activate the output",[1447,2276,2277,2282],{},[1481,2278,2279],{},[42,2280,2281],{},"XOR",[1481,2283,2284,2287],{},[42,2285,2286],{},"Exactly one"," switch must be ON - no more, no less",[1447,2289,2290,2295],{},[1481,2291,2292],{},[42,2293,2294],{},"NOT",[1481,2296,2297,2298,2301],{},"One specific switch ",[42,2299,2300],{},"must stay OFF"," for activation to happen",[1447,2303,2304,2309],{},[1481,2305,2306],{},[42,2307,2308],{},"NAND",[1481,2310,2311],{},"All switches must be OFF to activate the output node",[11,2313,2314],{},"You can reset the state, play around, and see how different input combinations affect the traversal and logic output - live.",[674,2316],{},[24,2318,2320],{"id":2319},"how-it-works-under-the-hood","How It Works Under the Hood",[11,2322,2323],{},"Wanderer uses:",[35,2325,2326,2331,2345,2351],{},[38,2327,2328],{},[42,2329,2330],{},"Depth-first graph traversal",[38,2332,2333,2336,2337,2128,2339,2128,2341,2344],{},[42,2334,2335],{},"Typed edges"," (e.g. ",[1206,2338,366],{},[1206,2340,370],{},[1206,2342,2343],{},"not",")",[38,2346,2347,2350],{},[42,2348,2349],{},"Node-local state",", no global context",[38,2352,2353,2354],{},"A reactive ",[42,2355,2356],{},"evaluation loop",[11,2358,2359],{},"Edges define everything:",[35,2361,2362,2367,2372],{},[38,2363,2364,2365,2344],{},"Which conditions are required (",[1206,2366,366],{},[38,2368,2369,2370,2344],{},"Which are optional (",[1206,2371,370],{},[38,2373,2374,2375,2377,2378,2344],{},"Which ",[42,2376,373],{}," be true (",[1206,2379,2343],{},[11,2381,2382],{},"It’s like building a circuit - but in a browser",[674,2384],{},[24,2386,2388],{"id":2387},"why-this-matters","Why This Matters",[11,2390,2391],{},"Visual flow builders often reach a ceiling:",[35,2393,2394,2397,2400],{},[38,2395,2396],{},"Too simple for complex logic",[38,2398,2399],{},"Too messy when scaled",[38,2401,2402],{},"Too code-like to stay no-code",[11,2404,2405],{},"Wanderer is an attempt to fix that.",[1211,2407,2408],{},[11,2409,2410],{},[382,2411,2412,2413,2415],{},"If we make logic truly visible,",[1740,2414],{},"\nwe make it understandable, shareable - and programmable.",[11,2417,2418,2419,2421],{},"Because when structure is the program,",[1740,2420],{},"\nyou don’t need to write code - you just connect ideas.",[674,2423],{},[24,2425,2427],{"id":2426},"who-this-is-for","Who This Is For",[35,2429,2430,2433,2436,2439,2442],{},[38,2431,2432],{},"Chatbot developers",[38,2434,2435],{},"No-code experimenters",[38,2437,2438],{},"UX designers & toolmakers",[38,2440,2441],{},"People who build GPT assistants",[38,2443,2444],{},"Educators teaching logic & flow",[11,2446,2447,2448,2451],{},"If you’ve ever wanted to ",[42,2449,2450],{},"build logic without writing logic",", Wanderer might be for you.",[674,2453],{},[24,2455,2457],{"id":2456},"lets-talk","Let’s Talk",[11,2459,2460],{},"I’d love feedback - and I’m curious:",[1211,2462,2463],{},[11,2464,2465],{},"Do you think this kind of logic modeling could change how we think about visual programming?",[11,2467,2468,2469,2471,2472,2475],{},"Hit me up with ideas, forks, or questions.",[1740,2470],{},"\nAnd if you're interested, I’ll publish a deeper article soon about how to ",[42,2473,2474],{},"combine gates",", build real-world flows, and even generate structures using GPTs.",[11,2477,2478],{},"Stay curious - and keep building.",[11,2480,2481,2482],{},"— Chris, Maker of ",[172,2483,398],{"href":2484,"rel":2485},"https:\u002F\u002Fwanderer-flow.de\u002F",[176],{"title":273,"searchDepth":274,"depth":274,"links":2487},[2488,2491,2492,2493,2494,2495,2496],{"id":2053,"depth":274,"text":2054,"children":2489},[2490],{"id":2102,"depth":1031,"text":2103},{"id":2171,"depth":274,"text":2172},{"id":2239,"depth":274,"text":2240},{"id":2319,"depth":274,"text":2320},{"id":2387,"depth":274,"text":2388},{"id":2426,"depth":274,"text":2427},{"id":2456,"depth":274,"text":2457},{"date":2498,"author":287,"headerImage":2499},"2025-07-07","\u002Fimages\u002Fblog\u002Fandgate.png","\u002Fblog\u002Fvisual-logic-without-code-can-this-change-the-way-we-build-flow-based-systems",{"title":2014,"description":273},{"loc":2500},"blog\u002Fvisual-logic-without-code-can-this-change-the-way-we-build-flow-based-systems","kuGlLuAuRhd6ityNnXh4L7vBjT2mMAKArwtMW8s8V-g",{"id":2506,"title":2507,"body":2508,"description":2512,"extension":284,"meta":2843,"navigation":289,"path":2846,"seo":2847,"sitemap":2848,"stem":2849,"__hash__":2850},"blog\u002Fblog\u002Frapid-chatbot-prototyping.md","Why Wanderer is Ideal for Rapid Chatbot Prototyping",{"type":8,"value":2509,"toc":2831},[2510,2513,2518,2524,2531,2535,2546,2549,2560,2563,2567,2570,2591,2594,2598,2601,2604,2624,2627,2638,2642,2645,2665,2672,2675,2689,2692,2696,2699,2710,2713,2717,2720,2731,2734,2745,2749,2752,2763,2766,2770,2786,2790,2812,2815,2818,2825],[11,2511,2512],{},"Building a chatbot sounds easy until you actually try. Whether you're crafting a support assistant, a survey interface, or a conversational product guide, one thing becomes clear fast:",[1211,2514,2515],{},[11,2516,2517],{},"Most chatbot platforms are either too rigid, too complex, or too opaque.",[11,2519,2520,2521,2523],{},"That’s why I built ",[42,2522,398],{}," - a fully visual, browser-based platform that makes chatbot prototyping fast, transparent, and logic-first.",[11,2525,2526,2527,2530],{},"This post explains why Wanderer is especially well-suited for ",[42,2528,2529],{},"rapid chatbot prototyping"," and how it helps teams go from idea to working prototype in minutes, not weeks.",[24,2532,2534],{"id":2533},"instant-feedback-no-setup-required","Instant Feedback, No Setup Required",[11,2536,2537,2538,2541,2542,2545],{},"Wanderer runs ",[42,2539,2540],{},"100% in the browser",", with ",[42,2543,2544],{},"no signup and no backend"," required. You can build a flow, connect a chat interface, and see it running instantly.",[11,2547,2548],{},"That means:",[35,2550,2551,2554,2557],{},[38,2552,2553],{},"No deployment delays",[38,2555,2556],{},"No configuration hell",[38,2558,2559],{},"No dev environments to sync",[11,2561,2562],{},"Just open the builder and prototype live.",[24,2564,2566],{"id":2565},"true-visual-programming","True Visual Programming",[11,2568,2569],{},"Unlike platforms where \"visual\" just means dragging blocks with hidden code, Wanderer takes visual logic seriously:",[35,2571,2572,2578,2584],{},[38,2573,2574,2577],{},[42,2575,2576],{},"Nodes"," perform actions: ask questions, show messages, set variables, call APIs",[38,2579,2580,2583],{},[42,2581,2582],{},"Edges"," control logic: determine when and why a Node runs",[38,2585,2586,2587,2590],{},"The entire flow is a ",[42,2588,2589],{},"graph"," that you can traverse, debug, and explain visually",[11,2592,2593],{},"No black-box logic. No hidden code. Just structure you can see and trust.",[24,2595,2597],{"id":2596},"structured-logic-first-chatbot-design","Structured, Logic-First Chatbot Design",[11,2599,2600],{},"Wanderer is not prompt-driven. It's not \"throw some text at a model and hope for the best.\"",[11,2602,2603],{},"Instead, you design:",[35,2605,2606,2612,2618],{},[38,2607,2608,2611],{},[42,2609,2610],{},"Questions and answer paths"," using structured Nodes",[38,2613,2614,2617],{},[42,2615,2616],{},"Stateful flows"," using Edge-based logic gates (AND, OR, NOT, XOR)",[38,2619,2620,2623],{},[42,2621,2622],{},"Dynamic content"," using Mustache templates and variable injection",[11,2625,2626],{},"This makes it easy to build bots that are:",[35,2628,2629,2632,2635],{},[38,2630,2631],{},"Deterministic",[38,2633,2634],{},"Testable",[38,2636,2637],{},"Maintainable",[820,2639,2641],{"id":2640},"what-about-prompts-and-gpts","What About Prompts and GPTs?",[11,2643,2644],{},"Yes, prompts and GPT nodes are supported - but they're not in control. In Wanderer, prompt nodes:",[35,2646,2647,2653,2659],{},[38,2648,2649,2652],{},[42,2650,2651],{},"Consume data from the graph"," (via state variables)",[38,2654,2655,2658],{},[42,2656,2657],{},"Generate structured output"," (like intents, JSON, or text)",[38,2660,2661,2664],{},[42,2662,2663],{},"Write results back into the graph"," as new variables",[11,2666,2667,2668,2671],{},"That means GPTs don't drive the logic - they ",[42,2669,2670],{},"extend it",". Your flow remains visual and explainable. Edges react to the output just like they would to any other variable.",[11,2673,2674],{},"You get the best of both worlds:",[35,2676,2677,2683],{},[38,2678,2679,2682],{},[42,2680,2681],{},"LLM flexibility"," for understanding or generating content",[38,2684,2685,2688],{},[42,2686,2687],{},"Graph control"," for logic, flow, and determinism",[11,2690,2691],{},"And it means you can evolve your prototype into production without rewriting everything.",[24,2693,2695],{"id":2694},"iteration-is-fast-and-fun","Iteration is Fast (and Fun)",[11,2697,2698],{},"Because the system is live and reactive:",[35,2700,2701,2704,2707],{},[38,2702,2703],{},"Any change you make in the flow updates the chat immediately",[38,2705,2706],{},"You can reset, replay, or branch your flow with a click",[38,2708,2709],{},"You can export and share flows as lightweight JSON files",[11,2711,2712],{},"You don’t have to wait for a server to restart, or a build to compile. You just iterate.",[24,2714,2716],{"id":2715},"designed-for-non-developers-and-devs-alike","Designed for Non-Developers and Devs Alike",[11,2718,2719],{},"Whether you're a UX designer, a therapist, or a technical founder:",[35,2721,2722,2725,2728],{},[38,2723,2724],{},"You can build meaningful flows without code",[38,2726,2727],{},"You can reason about logic without reading scripts",[38,2729,2730],{},"You can test ideas before involving a full dev team",[11,2732,2733],{},"For developers:",[35,2735,2736,2739,2742],{},[38,2737,2738],{},"Flows are versionable (plain JSON)",[38,2740,2741],{},"APIs are first-class citizens",[38,2743,2744],{},"Embedding in frontend apps is trivial",[24,2746,2748],{"id":2747},"shareable-by-default","Shareable by Default",[11,2750,2751],{},"Every flow in Wanderer can be exported, forked, or hosted via URL. That means:",[35,2753,2754,2757,2760],{},[38,2755,2756],{},"Easy collaboration with clients or teammates",[38,2758,2759],{},"Share prototypes in user testing sessions",[38,2761,2762],{},"Publish templates for your audience",[11,2764,2765],{},"No vendor lock-in. No walled garden.",[24,2767,2769],{"id":2768},"use-cases-that-work-today","Use Cases That Work Today",[35,2771,2772,2774,2777,2780,2783],{},[38,2773,1243],{},[38,2775,2776],{},"Therapy intake chatbots",[38,2778,2779],{},"Surveys and form-like interviews",[38,2781,2782],{},"Interactive onboarding assistants",[38,2784,2785],{},"Conversational tutorials",[24,2787,2789],{"id":2788},"tldr-why-wanderer-wins-for-chatbot-prototyping","TL;DR: Why Wanderer Wins for Chatbot Prototyping",[35,2791,2792,2797,2802,2807],{},[38,2793,2794],{},[42,2795,2796],{},"No code, no wait, no backend",[38,2798,2799],{},[42,2800,2801],{},"Real logic, real structure",[38,2803,2804],{},[42,2805,2806],{},"Debuggable and transparent",[38,2808,2809],{},[42,2810,2811],{},"Designed for iteration and experimentation",[11,2813,2814],{},"If you've ever felt limited by existing chatbot builders or frustrated by unpredictable LLM behavior, Wanderer gives you a clear, visual, and fast path to getting your ideas live.",[11,2816,2817],{},"Try Wanderer now. No signup. No install. Just open and build.",[11,2819,2820],{},[172,2821,2824],{"href":2822,"rel":2823},"https:\u002F\u002Fwanderer-flow.de\u002Fbuilder",[176],"Start the Builder",[11,2826,267,2827],{},[172,2828,2829],{"href":2829,"rel":2830},"https:\u002F\u002Fpixabay.com\u002Fde\u002Fphotos\u002Frakete-raketenstart-papierrakete-5676706\u002F",[176],{"title":273,"searchDepth":274,"depth":274,"links":2832},[2833,2834,2835,2838,2839,2840,2841,2842],{"id":2533,"depth":274,"text":2534},{"id":2565,"depth":274,"text":2566},{"id":2596,"depth":274,"text":2597,"children":2836},[2837],{"id":2640,"depth":1031,"text":2641},{"id":2694,"depth":274,"text":2695},{"id":2715,"depth":274,"text":2716},{"id":2747,"depth":274,"text":2748},{"id":2768,"depth":274,"text":2769},{"id":2788,"depth":274,"text":2789},{"date":2844,"author":287,"headerImage":2845},"2025-05-28","\u002Fimages\u002Fblog\u002Frocket.jpg","\u002Fblog\u002Frapid-chatbot-prototyping",{"title":2507,"description":2512},{"loc":2846},"blog\u002Frapid-chatbot-prototyping","6hSd5dI5DEFfcXr5DD2nL6XamOFqpmhCkJGQ3eXidSY",{"id":2852,"title":2853,"body":2854,"description":3141,"extension":284,"meta":3142,"navigation":289,"path":3145,"seo":3146,"sitemap":3147,"stem":3148,"__hash__":3149},"blog\u002Fblog\u002Fwhy-wanderer-is-the-perfect-framework-for-green-projects.md","Why Wanderer Is the Perfect Framework for Green Projects",{"type":8,"value":2855,"toc":3130},[2856,2871,2875,2878,2898,2901,2905,2920,2931,2938,2942,2945,2964,2967,2971,2974,2985,2992,2996,2999,3010,3017,3021,3024,3035,3038,3042,3045,3060,3067,3071,3103,3107,3114,3119,3124],[11,2857,2858,2860,2861,2128,2864,2132,2867,2870],{},[42,2859,398],{}," is a visual no-code agent builder built entirely in the frontend using Nuxt3 and Tailwind. At first glance, it might seem like a developer’s playground but beneath its sleek UI lies a philosophy that aligns beautifully with the values of ",[42,2862,2863],{},"sustainability",[42,2865,2866],{},"transparency",[42,2868,2869],{},"digital minimalism",". Here's why Wanderer is an excellent fit for green projects and eco-conscious initiatives.",[24,2872,2874],{"id":2873},"_1-100-frontend-0-server-load","1. 100% Frontend, 0% Server Load",[11,2876,2877],{},"Wanderer runs entirely in the user's browser. That means:",[35,2879,2880,2886,2892],{},[38,2881,2882,2885],{},[42,2883,2884],{},"No backend servers"," consuming energy around the clock.",[38,2887,2888,2891],{},[42,2889,2890],{},"No data centers"," storing unnecessary information.",[38,2893,2894,2897],{},[42,2895,2896],{},"No tracking, no registration",", just pure client-side logic.",[11,2899,2900],{},"This radically reduces the carbon footprint per user session, especially compared to server-heavy no-code or AI platforms.",[24,2902,2904],{"id":2903},"_2-transparent-visual-logic-wysiwyg","2. Transparent, Visual Logic (WYSIWYG)",[11,2906,2907,2908,2911,2912,2915,2916,2919],{},"Wanderer is truly ",[42,2909,2910],{},"what you see is what you get",". Every piece of logic is ",[42,2913,2914],{},"visually represented"," through ",[42,2917,2918],{},"nodes and edges",", and there's:",[35,2921,2922,2925,2928],{},[38,2923,2924],{},"No hidden scripts.",[38,2926,2927],{},"No obfuscated conditions.",[38,2929,2930],{},"No technical gatekeeping.",[11,2932,2933,2934,2937],{},"This makes it ideal for ",[42,2935,2936],{},"public or community-driven"," projects where openness and traceability are key.",[24,2939,2941],{"id":2940},"_3-data-minimalism-by-design","3. Data Minimalism by Design",[11,2943,2944],{},"Wanderer stores only what’s necessary:",[35,2946,2947,2954,2957],{},[38,2948,2949,2950,2953],{},"Flows are pure ",[42,2951,2952],{},"JSON files",", versionable and shareable.",[38,2955,2956],{},"State management is local (IndexedDB or LocalStorage), keeping user data private.",[38,2958,2959,2960,2963],{},"The system ",[42,2961,2962],{},"doesn’t require login or cloud sync"," to function.",[11,2965,2966],{},"This approach supports digital sobriety - only using what’s truly needed.",[24,2968,2970],{"id":2969},"_4-reusability-forkability","4. Reusability & Forkability",[11,2972,2973],{},"Each visual flow is a self-contained file. You can:",[35,2975,2976,2979,2982],{},[38,2977,2978],{},"Fork flows.",[38,2980,2981],{},"Share them openly.",[38,2983,2984],{},"Remix them for different needs.",[11,2986,2987,2988,2991],{},"This encourages a ",[42,2989,2990],{},"circular economy of logic"," instead of rebuilding from scratch, you adapt and evolve existing knowledge.",[24,2993,2995],{"id":2994},"_5-lightweight-and-accessible","5. Lightweight and Accessible",[11,2997,2998],{},"Built with performance in mind, Wanderer:",[35,3000,3001,3004,3007],{},[38,3002,3003],{},"Works on low-power devices.",[38,3005,3006],{},"Requires no installation or setup.",[38,3008,3009],{},"Loads instantly in the browser.",[11,3011,3012,3013,3016],{},"Ideal for ",[42,3014,3015],{},"resource-constrained environments",", educational settings, or community workshops especially in regions where digital access is limited.",[24,3018,3020],{"id":3019},"_6-ethical-ai-chatbot-prototyping","6. Ethical AI & Chatbot Prototyping",[11,3022,3023],{},"For green projects involving user interaction like surveys, coaching, or public participation tools Wanderer supports:",[35,3025,3026,3029,3032],{},[38,3027,3028],{},"Intuitive chatbot flows.",[38,3030,3031],{},"Interactive decision trees.",[38,3033,3034],{},"Adaptive interfaces via GPT-assisted nodes (with opt-in control).",[11,3036,3037],{},"Since logic and flow are always visual, AI remains under user control, transparent and explainable.",[24,3039,3041],{"id":3040},"_7-built-for-experimentation-not-lock-in","7. Built for Experimentation, Not Lock-In",[11,3043,3044],{},"Many tools push users into proprietary formats or expensive ecosystems. Wanderer does the opposite:",[35,3046,3047,3054,3057],{},[38,3048,3049,3050,3053],{},"It’s ",[42,3051,3052],{},"open by default",": files can be stored, read, or modified anywhere.",[38,3055,3056],{},"Compatible with Git, JSON, document databases, and even graph databases.",[38,3058,3059],{},"Flows can be loaded from public URLs (e.g., GitHub) and restored instantly.",[11,3061,3062,3063,3066],{},"This freedom makes it easy to build ",[42,3064,3065],{},"open-source sustainability tools",", participatory apps, or educational demos without long-term lock-in.",[24,3068,3070],{"id":3069},"ideal-use-cases-in-the-green-sector","Ideal Use Cases in the Green Sector",[35,3072,3073,3079,3085,3091,3097],{},[38,3074,3075,3078],{},[42,3076,3077],{},"Therapists"," designing mindfulness journeys.",[38,3080,3081,3084],{},[42,3082,3083],{},"NGOs"," building public education bots.",[38,3086,3087,3090],{},[42,3088,3089],{},"Eco startups"," prototyping configurators for sustainable products.",[38,3092,3093,3096],{},[42,3094,3095],{},"Civic tech teams"," facilitating participation through smart chat flows.",[38,3098,3099,3102],{},[42,3100,3101],{},"Researchers"," designing logic-based anamnese or assessments.",[24,3104,3106],{"id":3105},"final-thought-software-that-aligns-with-your-values","Final Thought: Software That Aligns With Your Values",[11,3108,3109,3110,3113],{},"In a world flooded with bloated SaaS tools and hidden logic, ",[42,3111,3112],{},"Wanderer takes a radically transparent, lightweight, and ethical approach",". It’s more than a framework - it’s a statement. If your project is green at heart, your tools should be too.",[1211,3115,3116],{},[11,3117,3118],{},"Try Wanderer today - no login, no data collection, just click and build.",[11,3120,3121],{},[172,3122,2824],{"href":2822,"rel":3123},[176],[11,3125,267,3126],{},[172,3127,3128],{"href":3128,"rel":3129},"https:\u002F\u002Fpixabay.com\u002Fde\u002Fphotos\u002Fpark-wind-wolken-energie-mills-3704939\u002F",[176],{"title":273,"searchDepth":274,"depth":274,"links":3131},[3132,3133,3134,3135,3136,3137,3138,3139,3140],{"id":2873,"depth":274,"text":2874},{"id":2903,"depth":274,"text":2904},{"id":2940,"depth":274,"text":2941},{"id":2969,"depth":274,"text":2970},{"id":2994,"depth":274,"text":2995},{"id":3019,"depth":274,"text":3020},{"id":3040,"depth":274,"text":3041},{"id":3069,"depth":274,"text":3070},{"id":3105,"depth":274,"text":3106},"Wanderer is a visual no-code agent builder built entirely in the frontend using Nuxt3 and Tailwind. At first glance, it might seem like a developer’s playground but beneath its sleek UI lies a philosophy that aligns beautifully with the values of sustainability, transparency, and digital minimalism. Here's why Wanderer is an excellent fit for green projects and eco-conscious initiatives.",{"date":3143,"author":287,"headerImage":3144},"2025-05-26","\u002Fimages\u002Fblog\u002Fwindpark.jpg","\u002Fblog\u002Fwhy-wanderer-is-the-perfect-framework-for-green-projects",{"title":2853,"description":3141},{"loc":3145},"blog\u002Fwhy-wanderer-is-the-perfect-framework-for-green-projects","v-ZmCxx4ms93b5ve62VMFOC1pcIqI_tz3PB-HU5GfHA",{"id":3151,"title":3152,"body":3153,"description":273,"extension":284,"meta":3453,"navigation":289,"path":3456,"seo":3457,"sitemap":3458,"stem":3459,"__hash__":3460},"blog\u002Fblog\u002Fwhy-wanderer-is-ideal-for-privacy-focused-projects.md","Why Wanderer is Ideal for Privacy-Focused Projects",{"type":8,"value":3154,"toc":3443},[3155,3160,3163,3168,3175,3179,3182,3185,3202,3205,3209,3212,3223,3226,3240,3244,3251,3262,3265,3276,3280,3287,3309,3312,3316,3319,3330,3333,3344,3348,3351,3362,3365,3376,3380,3383,3397,3400,3404,3426,3429,3432,3437],[1211,3156,3157],{},[11,3158,3159],{},"Privacy isn't a feature. It's a foundation.",[11,3161,3162],{},"And yet, many tools that claim to be “no-code” or “AI-powered” quietly ship your data off to cloud servers, third-party APIs, or tracking layers you can’t see - let alone control.",[11,3164,3165],{},[42,3166,3167],{},"Wanderer was built differently.",[11,3169,3170,3171,3174],{},"In this post, I’ll explain why Wanderer is uniquely well-suited for ",[42,3172,3173],{},"privacy-focused projects"," - and how it helps developers, designers, and researchers build logic-first, privacy-respecting conversational flows directly in the browser.",[24,3176,3178],{"id":3177},"runs-100-in-the-browser","Runs 100% in the Browser",[11,3180,3181],{},"Wanderer runs entirely client-side. No data ever leaves the browser unless you explicitly call an external API using a configured Node.",[11,3183,3184],{},"This means:",[35,3186,3187,3192,3197],{},[38,3188,3189],{},[42,3190,3191],{},"No server storage",[38,3193,3194],{},[42,3195,3196],{},"No analytics tracking",[38,3198,3199],{},[42,3200,3201],{},"No hidden network calls",[11,3203,3204],{},"What you build and test stays local by default.",[24,3206,3208],{"id":3207},"no-hidden-ai-or-cloud-dependencies","No Hidden AI or Cloud Dependencies",[11,3210,3211],{},"Wanderer doesn’t rely on external LLMs, SaaS services, or black-box APIs.",[35,3213,3214,3217,3220],{},[38,3215,3216],{},"There is no “magic AI” guessing intent.",[38,3218,3219],{},"No data is streamed to OpenAI, Google, or elsewhere.",[38,3221,3222],{},"The logic you define is the logic that runs.",[11,3224,3225],{},"That’s essential for regulated environments like:",[35,3227,3228,3231,3234,3237],{},[38,3229,3230],{},"Healthcare",[38,3232,3233],{},"Mental health",[38,3235,3236],{},"Legal workflows",[38,3238,3239],{},"Internal enterprise tools",[24,3241,3243],{"id":3242},"local-data-local-control","Local Data, Local Control",[11,3245,3246,3247,3250],{},"All state, flow structure, and execution happen ",[42,3248,3249],{},"in-memory"," or in local browser storage (if enabled). You can export and import flows as plain JSON.",[35,3252,3253,3256,3259],{},[38,3254,3255],{},"Nothing is stored on a server.",[38,3257,3258],{},"Nothing is shared unless you choose to.",[38,3260,3261],{},"You control how long data persists.",[11,3263,3264],{},"This makes Wanderer ideal for use cases like:",[35,3266,3267,3270,3273],{},[38,3268,3269],{},"Anonymous feedback bots",[38,3271,3272],{},"Sensitive intake forms",[38,3274,3275],{},"Educational environments with data protection needs",[24,3277,3279],{"id":3278},"gdpr-hipaa-and-beyond","GDPR, HIPAA, and Beyond",[11,3281,3282,3283,3286],{},"While Wanderer itself doesn’t claim certification under GDPR or HIPAA, its architecture supports ",[42,3284,3285],{},"privacy-first compliance"," strategies:",[35,3288,3289,3294,3299,3304],{},[38,3290,3291],{},[42,3292,3293],{},"No user account required",[38,3295,3296],{},[42,3297,3298],{},"No personal data collected by default",[38,3300,3301],{},[42,3302,3303],{},"Exportable audit trail via JSON files",[38,3305,3306],{},[42,3307,3308],{},"Full flow transparency for internal reviews",[11,3310,3311],{},"If you need to build a chatbot or interaction flow inside a regulated domain, Wanderer gives you a compliant starting point.",[24,3313,3315],{"id":3314},"transparent-logic-explainable-behavior","Transparent Logic, Explainable Behavior",[11,3317,3318],{},"Many AI tools are unexplainable. Wanderer is the opposite.",[35,3320,3321,3324,3327],{},[38,3322,3323],{},"Logic lives in Edges and Nodes.",[38,3325,3326],{},"Conditions are visible and testable.",[38,3328,3329],{},"State is inspectable at every step.",[11,3331,3332],{},"That means you can:",[35,3334,3335,3338,3341],{},[38,3336,3337],{},"Debug flows with confidence",[38,3339,3340],{},"Explain decision paths to auditors or stakeholders",[38,3342,3343],{},"Trust that your chatbot is doing exactly what it says it does",[24,3345,3347],{"id":3346},"offline-ready-by-design","Offline-Ready by Design",[11,3349,3350],{},"Because Wanderer is a frontend-only app, it can run:",[35,3352,3353,3356,3359],{},[38,3354,3355],{},"In a secure local environment",[38,3357,3358],{},"On intranet systems",[38,3360,3361],{},"Even entirely offline (with assets cached)",[11,3363,3364],{},"Perfect for:",[35,3366,3367,3370,3373],{},[38,3368,3369],{},"Privacy-conscious institutions",[38,3371,3372],{},"Classroom use without internet access",[38,3374,3375],{},"Air-gapped research projects",[24,3377,3379],{"id":3378},"build-without-exposure","Build Without Exposure",[11,3381,3382],{},"You shouldn’t need to sacrifice privacy just to prototype. Wanderer lets you:",[35,3384,3385,3391,3394],{},[38,3386,3387,3388],{},"Build and run chatbots ",[42,3389,3390],{},"without exposing any data",[38,3392,3393],{},"Share flows as static files or hosted JSON",[38,3395,3396],{},"Avoid cloud lock-in or surveillance risk",[11,3398,3399],{},"Whether you're working in a hospital, a school, or your own secure R&D lab, Wanderer keeps the control - and the data - in your hands.",[24,3401,3403],{"id":3402},"tldr-why-wanderer-wins-for-privacy-centric-builds","TL;DR: Why Wanderer Wins for Privacy-Centric Builds",[35,3405,3406,3411,3416,3421],{},[38,3407,3408],{},[42,3409,3410],{},"No cloud backend, no hidden sync",[38,3412,3413],{},[42,3414,3415],{},"Everything runs local",[38,3417,3418],{},[42,3419,3420],{},"No required user data, no tracking",[38,3422,3423],{},[42,3424,3425],{},"Full transparency and exportability",[11,3427,3428],{},"If your project demands privacy, transparency, and full control - Wanderer is the builder you’ve been looking for.",[11,3430,3431],{},"Try Wanderer privately. No signup. No tracking. Just open, build, and own your logic.",[11,3433,3434],{},[172,3435,2824],{"href":2822,"rel":3436},[176],[11,3438,267,3439],{},[172,3440,3441],{"href":3441,"rel":3442},"https:\u002F\u002Fpixabay.com\u002Fde\u002Fphotos\u002Fschloss-offenes-schloss-2554294\u002F",[176],{"title":273,"searchDepth":274,"depth":274,"links":3444},[3445,3446,3447,3448,3449,3450,3451,3452],{"id":3177,"depth":274,"text":3178},{"id":3207,"depth":274,"text":3208},{"id":3242,"depth":274,"text":3243},{"id":3278,"depth":274,"text":3279},{"id":3314,"depth":274,"text":3315},{"id":3346,"depth":274,"text":3347},{"id":3378,"depth":274,"text":3379},{"id":3402,"depth":274,"text":3403},{"date":3454,"author":287,"headerImage":3455},"2025-05-25","\u002Fimages\u002Fblog\u002Flock.jpg","\u002Fblog\u002Fwhy-wanderer-is-ideal-for-privacy-focused-projects",{"title":3152,"description":273},{"loc":3456},"blog\u002Fwhy-wanderer-is-ideal-for-privacy-focused-projects","butYoVEdmR5aNPbkxyr85r4yxJjnwZNLUcBX3Bt1HeI",{"id":3462,"title":3463,"body":3464,"description":3710,"extension":284,"meta":3711,"navigation":289,"path":3714,"seo":3715,"sitemap":3716,"stem":3717,"__hash__":3718},"blog\u002Fblog\u002Frepeatable-questions-in-visual-chatbot-flows.md","Repeatable Questions in Visual Chatbot Flows",{"type":8,"value":3465,"toc":3703},[3466,3473,3476,3480,3483,3489,3500,3503,3507,3514,3516,3544,3551,3555,3581,3584,3588,3595,3609,3612,3616,3619,3627,3630,3650,3660,3680,3687,3692,3697],[11,3467,3468,3469,3472],{},"What if users could go back and ",[42,3470,3471],{},"change their answers"," in a chatbot conversation without breaking the logic or losing progress?",[11,3474,3475],{},"With traditional bot builders, this is a headache. But with Wanderer's visual logic graph, it's not only possible - it's built-in.",[24,3477,3479],{"id":3478},"the-problem-static-conversations","The Problem: Static Conversations",[11,3481,3482],{},"In most chatbot platforms, questions are treated as linear and immutable. Once answered, the conversation moves forward - permanently.",[11,3484,3485,3486,1104],{},"But what if a user ",[42,3487,3488],{},"changes their mind",[35,3490,3491,3494,3497],{},[38,3492,3493],{},"Restarting the chat? Not great UX.",[38,3495,3496],{},"Undo buttons? Rarely exist.",[38,3498,3499],{},"Dynamic backtracking? Technically hard.",[11,3501,3502],{},"The reason: most bots are built on rigid, tree-like or rule-based logic. Changing one answer risks collapsing everything that depends on it.",[24,3504,3506],{"id":3505},"the-solution-reversible-graph-logic","The Solution: Reversible Graph Logic",[11,3508,3509,3510,3513],{},"Wanderer is based on a dynamic ",[42,3511,3512],{},"graph traversal engine",", where each question, answer, and decision point is a node in a live visual graph.",[11,3515,3184],{},[35,3517,3518,3525,3532,3538],{},[38,3519,3520,3521,3524],{},"Each question tracks its ",[42,3522,3523],{},"state"," independently.",[38,3526,3527,3528,3531],{},"Nodes can be ",[42,3529,3530],{},"reset"," at runtime.",[38,3533,3534,3535,203],{},"Edges dynamically determine whether a question is still ",[42,3536,3537],{},"contextually valid",[38,3539,3540,3541,203],{},"Once a question is back in context, it can be safely ",[42,3542,3543],{},"repeated and updated",[11,3545,3546,3547,3550],{},"This allows for ",[42,3548,3549],{},"true reactivity"," in chatbot flows where user input can evolve and rewire the conversation logic on the fly.",[24,3552,3554],{"id":3553},"how-it-works-in-wanderer","How It Works in Wanderer",[35,3556,3557,3562,3568,3575],{},[38,3558,3559,3560,203],{},"Every question is a ",[42,3561,495],{},[38,3563,3564,3565,203],{},"Every condition is an ",[42,3566,3567],{},"edge",[38,3569,3570,3571,3574],{},"Context is managed by the ",[42,3572,3573],{},"traversal engine",", not by hardcoded state machines.",[38,3576,3577,3578,203],{},"A node becomes repeatable again only if it’s ",[42,3579,3580],{},"reachable and relevant",[11,3582,3583],{},"Because logic lives in the edges (not hidden in code) flows are transparent, editable, and reversible.",[24,3585,3587],{"id":3586},"why-it-matters","Why It Matters",[11,3589,3590,3591,3594],{},"Giving users the ability to ",[42,3592,3593],{},"rethink decisions"," is a key feature for:",[35,3596,3597,3600,3603,3606],{},[38,3598,3599],{},"Configurators and wizards",[38,3601,3602],{},"Decision support tools",[38,3604,3605],{},"Mental health check-ins or coaching bots",[38,3607,3608],{},"Any complex interaction where choices evolve",[11,3610,3611],{},"With Wanderer, this doesn't require hacking logic or duplicating questions. It's part of the system's DNA.",[24,3613,3615],{"id":3614},"isnt-this-already-possible-in-other-tools","Isn’t This Already Possible in Other Tools?",[11,3617,3618],{},"Some chatbot platforms offer simple \"go back\" buttons or hardcoded navigation like:",[35,3620,3621,3624],{},[38,3622,3623],{},"“Undo last answer”",[38,3625,3626],{},"“Return to previous step”",[11,3628,3629],{},"But these features are usually:",[35,3631,3632,3638,3644],{},[38,3633,3634,3637],{},[42,3635,3636],{},"Hardwired",": They don’t evaluate context or conditions.",[38,3639,3640,3643],{},[42,3641,3642],{},"Linear",": You can only go back one step.",[38,3645,3646,3649],{},[42,3647,3648],{},"Blind to logic",": Changing an earlier answer often breaks the rest of the flow or forces a restart.",[11,3651,3652,3653,3656,3657,1681],{},"With Wanderer, repeatable questions are ",[42,3654,3655],{},"not an afterthought",". They are part of the graph's ",[42,3658,3659],{},"logical structure",[35,3661,3662,3668,3674],{},[38,3663,3664,3665,203],{},"A question only becomes repeatable if its ",[42,3666,3667],{},"context is valid",[38,3669,2230,3670,3673],{},[42,3671,3672],{},"reset any node",", and the system will automatically update downstream logic.",[38,3675,3676,3677,3679],{},"The graph remains ",[42,3678,1103],{}," and adapts in real time without hacks.",[11,3681,3682,3683,3686],{},"This isn't \"rewind.\" It's ",[42,3684,3685],{},"true dynamic state correction"," within a live logic graph.",[1211,3688,3689],{},[11,3690,3691],{},"Great conversations are flexible. Your chatbot should be too.",[11,3693,3694],{},[172,3695,2824],{"href":2822,"rel":3696},[176],[11,3698,267,3699],{},[172,3700,3701],{"href":3701,"rel":3702},"https:\u002F\u002Fpixabay.com\u002Fde\u002Fphotos\u002Ffrage-fragezeichen-tafel-schule-2709670\u002F",[176],{"title":273,"searchDepth":274,"depth":274,"links":3704},[3705,3706,3707,3708,3709],{"id":3478,"depth":274,"text":3479},{"id":3505,"depth":274,"text":3506},{"id":3553,"depth":274,"text":3554},{"id":3586,"depth":274,"text":3587},{"id":3614,"depth":274,"text":3615},"What if users could go back and change their answers in a chatbot conversation without breaking the logic or losing progress?",{"date":3712,"author":287,"headerImage":3713},"2025-05-16","\u002Fimages\u002Fblog\u002Fquestion.jpg","\u002Fblog\u002Frepeatable-questions-in-visual-chatbot-flows",{"title":3463,"description":3710},{"loc":3714},"blog\u002Frepeatable-questions-in-visual-chatbot-flows","UP3TbDPGA9zcj7qqy2RkIoZnhAqdJlwbPaKPDyErwy0",{"id":3720,"title":3721,"body":3722,"description":273,"extension":284,"meta":4103,"navigation":289,"path":4106,"seo":4107,"sitemap":4108,"stem":4109,"__hash__":4110},"blog\u002Fblog\u002Fwhy-all-logiclives-in-the-edges.md","Why All Logic Lives in the Edges",{"type":8,"value":3723,"toc":4091},[3724,3735,3738,3742,3745,3769,3776,3779,3788,3792,3795,3807,3810,3839,3846,3850,3856,3859,3878,3881,3895,3902,3904,3908,3911,3930,3933,3938,3942,3945,3956,3960,3963,3982,3985,3999,4003,4012,4019,4033,4040,4047,4051,4057,4060,4077,4080,4085],[1211,3725,3726],{},[11,3727,3728,3729,3731,3734],{},"If connecting two nodes with an edge already forms a causal relationship -",[1740,3730],{},[382,3732,3733],{},"\"If A happens, then B follows\""," -\nthen why should logic be defined anywhere else?",[11,3736,3737],{},"That question became the foundation of Wanderer's architecture.",[24,3739,3741],{"id":3740},"the-initial-insight-causality-through-connection","The Initial Insight: Causality Through Connection",[11,3743,3744],{},"In many visual flow builders, connecting two nodes with an arrow (or \"edge\") implies a relationship:",[35,3746,3747,3753,3759,3764],{},[38,3748,3749,3752],{},[42,3750,3751],{},"If"," this message was shown,",[38,3754,3755,3758],{},[42,3756,3757],{},"then"," ask this question.",[38,3760,3761,3763],{},[42,3762,3751],{}," this API returned true,",[38,3765,3766,3768],{},[42,3767,3757],{}," continue here.",[11,3770,3771,3772,3775],{},"The edge ",[42,3773,3774],{},"represents logic"," - even if it's just temporal (\"then do this\") or conditional (\"if this, then that\").",[11,3777,3778],{},"So the next step was obvious:",[1211,3780,3781],{},[11,3782,3783,3784,3787],{},"What if ",[382,3785,3786],{},"all"," logic - even complex logical gates - could live in the edges?",[24,3789,3791],{"id":3790},"the-problem-with-other-builders","The Problem With Other Builders",[11,3793,3794],{},"Most visual tools mix logic in two places:",[35,3796,3797,3802],{},[38,3798,3799,3801],{},[42,3800,2582],{}," for simple connections.",[38,3803,3804,3806],{},[42,3805,2576],{}," for conditions, branching, even scripting.",[11,3808,3809],{},"This causes problems:",[743,3811,3812,3821,3827,3833],{},[38,3813,3814,3817,3818,3820],{},[42,3815,3816],{},"Hidden logic",": You don’t know ",[382,3819,836],{}," a decision is made.",[38,3822,3823,3826],{},[42,3824,3825],{},"Inconsistent logic",": Sometimes edges decide, sometimes nodes.",[38,3828,3829,3832],{},[42,3830,3831],{},"Code in nodes",": Flow becomes dependent on internal node behavior or black-box scripts.",[38,3834,3835,3838],{},[42,3836,3837],{},"Non-visual logic",": The graph stops being the source of truth.",[11,3840,3841,3842,3845],{},"In such systems, the graph is no longer a ",[42,3843,3844],{},"visual representation of program logic"," - it's just a UI for wiring hidden internals.",[24,3847,3849],{"id":3848},"the-wanderer-approach-edges-as-first-class-logic","The Wanderer Approach: Edges as First-Class Logic",[11,3851,3852,3853,203],{},"In Wanderer, edges aren’t just wires - they are ",[42,3854,3855],{},"logic gates",[11,3857,3858],{},"Each edge defines:",[35,3860,3861,3867,3872],{},[38,3862,3863,3866],{},[42,3864,3865],{},"Whether"," it can be traversed",[38,3868,3869],{},[42,3870,3871],{},"Under which condition",[38,3873,3874,3877],{},[42,3875,3876],{},"What it means"," for the next node to activate",[11,3879,3880],{},"Node types remain simple:",[35,3882,3883,3886,3889,3892],{},[38,3884,3885],{},"Display a message",[38,3887,3888],{},"Ask a question",[38,3890,3891],{},"Store a variable",[38,3893,3894],{},"Call an API",[11,3896,3897,3898,3901],{},"But they never decide ",[42,3899,3900],{},"what comes next",". That’s the edge’s job.",[24,3903,2388],{"id":2387},[820,3905,3907],{"id":3906},"_1-visual-logic-is-understandable-logic","1. Visual Logic Is Understandable Logic",[11,3909,3910],{},"When logic lives in the edges:",[35,3912,3913,3918,3924],{},[38,3914,2230,3915,3917],{},[42,3916,2159],{}," the condition.",[38,3919,2230,3920,3923],{},[42,3921,3922],{},"combine"," multiple edges into AND \u002F OR gates.",[38,3925,2230,3926,3929],{},[42,3927,3928],{},"trace"," decisions without reading code.",[11,3931,3932],{},"This aligns perfectly with Wanderer’s goal:",[1211,3934,3935],{},[11,3936,3937],{},"WYSIWYG logic. What you draw is what it does.",[820,3939,3941],{"id":3940},"_2-logic-is-modular-and-testable","2. Logic Is Modular and Testable",[11,3943,3944],{},"Since conditions are declared on edges:",[35,3946,3947,3950,3953],{},[38,3948,3949],{},"You can test them in isolation.",[38,3951,3952],{},"You can reuse the same node with different logic pathways.",[38,3954,3955],{},"You can modify behavior without touching the node.",[820,3957,3959],{"id":3958},"_3-graphs-become-executable","3. Graphs Become Executable",[11,3961,3962],{},"Because logic is fully embedded in the graph:",[35,3964,3965,3972,3975],{},[38,3966,3967,3968,3971],{},"The traversal engine can ",[42,3969,3970],{},"walk the graph"," and make decisions.",[38,3973,3974],{},"There’s no need to \"evaluate\" node internals.",[38,3976,3977,3978,3981],{},"Logic becomes ",[42,3979,3980],{},"data",", not code.",[11,3983,3984],{},"This makes flows easier to:",[35,3986,3987,3990,3993,3996],{},[38,3988,3989],{},"Version",[38,3991,3992],{},"Share",[38,3994,3995],{},"Fork",[38,3997,3998],{},"Export",[24,4000,4002],{"id":4001},"example-building-a-logical-gate-visually","Example: Building a Logical Gate Visually",[11,4004,4005,4006,4008,4009,203],{},"Let’s say we have a ",[42,4007,495],{}," that sets the state ",[1206,4010,4011],{},"user.stressed = true",[11,4013,4014,4015,4018],{},"You can now create two ",[42,4016,4017],{},"must-edges"," leading to the next question node:",[35,4020,4021,4027],{},[38,4022,4023,4024],{},"One edge checks: ",[1206,4025,4026],{},"user.stressed == true",[38,4028,4029,4030],{},"Another edge checks: ",[1206,4031,4032],{},"user.age > 30",[11,4034,4035,4036,4039],{},"Only if ",[382,4037,4038],{},"both"," edges are traversed successfully will the next question appear.",[11,4041,4042,4043,4046],{},"You’ve just built an ",[42,4044,4045],{},"AND gate",", entirely visually - and entirely through edges.",[24,4048,4050],{"id":4049},"final-thought-logic-belongs-to-the-connections","Final Thought: Logic Belongs to the Connections",[11,4052,4053,4054,4056],{},"Nodes are actions.",[1740,4055],{},"\nEdges are decisions.",[11,4058,4059],{},"By giving all logic to the edges, we create a system where:",[35,4061,4062,4067,4072],{},[38,4063,4064],{},[42,4065,4066],{},"Causality is always visible",[38,4068,4069],{},[42,4070,4071],{},"The graph is the program",[38,4073,4074],{},[42,4075,4076],{},"Every decision is explicit",[11,4078,4079],{},"This is what makes Wanderer different.",[11,4081,4082],{},[172,4083,2824],{"href":2822,"rel":4084},[176],[11,4086,267,4087],{},[172,4088,4089],{"href":4089,"rel":4090},"https:\u002F\u002Fpixabay.com\u002Fillustrations\u002Fbrain-left-logic-science-5662028\u002F",[176],{"title":273,"searchDepth":274,"depth":274,"links":4092},[4093,4094,4095,4096,4101,4102],{"id":3740,"depth":274,"text":3741},{"id":3790,"depth":274,"text":3791},{"id":3848,"depth":274,"text":3849},{"id":2387,"depth":274,"text":2388,"children":4097},[4098,4099,4100],{"id":3906,"depth":1031,"text":3907},{"id":3940,"depth":1031,"text":3941},{"id":3958,"depth":1031,"text":3959},{"id":4001,"depth":274,"text":4002},{"id":4049,"depth":274,"text":4050},{"date":4104,"author":287,"headerImage":4105},"2025-05-12","\u002Fimages\u002Fblog\u002Fbrain.jpg","\u002Fblog\u002Fwhy-all-logiclives-in-the-edges",{"title":3721,"description":273},{"loc":4106},"blog\u002Fwhy-all-logiclives-in-the-edges","VShpgEEu4YPyBnEnAr3-CzK0_Bd6Hce2O_PiAKQxkd0",{"id":4112,"title":4113,"body":4114,"description":4118,"extension":284,"meta":4231,"navigation":289,"path":4234,"seo":4235,"sitemap":4236,"stem":4237,"__hash__":4238},"blog\u002Fblog\u002Fwhy-i-built-wanderer.md","Why I Built Wanderer",{"type":8,"value":4115,"toc":4223},[4116,4119,4124,4127,4131,4140,4146,4150,4153,4163,4167,4170,4176,4180,4183,4189,4193,4196,4202,4206,4209,4212,4217],[11,4117,4118],{},"When I started working on Wanderer, I wasn’t just building a tool - I was questioning the very foundation of how chatbots are typically created.",[1211,4120,4121],{},[11,4122,4123],{},"Just open your browser, and start building.",[11,4125,4126],{},"From my experience, most bot builders are overly complex, hard to maintain, and designed in a way that hides their inner workings. Too often, the journey from real-world problem to digital conversation feels like a compromise. Wanderer is my attempt to change that: to make chat logic visible, transparent, and radically accessible.",[24,4128,4130],{"id":4129},"_1-programming-shouldnt-be-a-barrier","1. Programming Shouldn’t Be a Barrier",[11,4132,4133,4134,4137,4138,203],{},"Designing chatbot conversations often means diving into conditionals, variables, and scripting even just to make a basic flow work. It becomes programming, not designing. That complexity alienates people who actually understand the ",[382,4135,4136],{},"content"," but not the ",[382,4139,1206],{},[11,4141,4142,4145],{},[42,4143,4144],{},"Wanderer flips that dynamic."," It’s a visual system where logic lives in the graph itself. No hidden code. No technical hurdles. Just nodes, edges, and clear logic you can see and understand at a glance.",[24,4147,4149],{"id":4148},"_2-visual-logic-over-guesswork","2. Visual Logic Over Guesswork",[11,4151,4152],{},"In traditional platforms, as conversations grow, they quickly become hard to follow. It’s difficult to see which input triggers what response, or why a particular branch was chosen.",[11,4154,4155,4156,4159,4160,4162],{},"Wanderer solves this with ",[42,4157,4158],{},"a graph-first approach",". You don’t just build your bot you ",[382,4161,2159],{}," it work. Every edge, condition, and state is visible and debuggable. The live traversal path is shown directly in the editor. It's not just WYSIWYG-it's WYSIWY-DO.",[24,4164,4166],{"id":4165},"_3-no-more-black-boxes","3. No More Black Boxes",[11,4168,4169],{},"Too many platforms feel like black boxes. You don't know how they work, where your data goes, or whether the company behind them will still exist next year. You’re locked into pricing plans, hidden limits, and external dependencies.",[11,4171,4172,4175],{},[42,4173,4174],{},"Wanderer is fully transparent and runs entirely in your browser."," There’s no backend. No data collection. No vendor lock-in. Just a self-contained, visual programming environment that works out of the box right in the frontend.",[24,4177,4179],{"id":4178},"_4-privacy-and-client-side-execution","4. Privacy and Client-Side Execution",[11,4181,4182],{},"Why do we send every user message across the internet just to receive a canned response? With modern browsers and edge computing, there's no technical reason for most bots to require a server at all.",[11,4184,4185,4188],{},[42,4186,4187],{},"Wanderer proves that powerful chat logic can live on the client."," It's private by default. What you build stays in your browser unless you decide to share it.",[24,4190,4192],{"id":4191},"_5-let-knowledge-flow-again","5. Let Knowledge Flow Again",[11,4194,4195],{},"Much of today’s chatbot knowledge is trapped or buried in platforms, APIs, or proprietary formats. It’s difficult to extract, hard to repurpose, and nearly impossible to remix.",[11,4197,4198,4201],{},[42,4199,4200],{},"Wanderer uses open, text-based JSON for every flow."," It’s readable, shareable, and forkable. That means knowledge can circulate freely again between people, teams, and tools. Bots become part of a commons, not walled gardens.",[24,4203,4205],{"id":4204},"a-new-philosophy-of-chatbot-design","A New Philosophy of Chatbot Design",[11,4207,4208],{},"Wanderer is more than a tool - it’s an experiment in simplicity and openness. I want to see what happens when anyone, regardless of coding skill, can design meaningful conversations using only visual logic. When AI assistants can be transparent. When chatbots can be lightweight, forkable, and free.",[11,4210,4211],{},"If you've ever felt limited by the chatbot tools available today, I invite you to try Wanderer. No login. No tracking. No black box.",[11,4213,4214],{},[172,4215,2824],{"href":2822,"rel":4216},[176],[11,4218,267,4219],{},[172,4220,4221],{"href":4221,"rel":4222},"https:\u002F\u002Fpixabay.com\u002Fde\u002Fphotos\u002Fwerkzeuge-konstruieren-boot-864983\u002F",[176],{"title":273,"searchDepth":274,"depth":274,"links":4224},[4225,4226,4227,4228,4229,4230],{"id":4129,"depth":274,"text":4130},{"id":4148,"depth":274,"text":4149},{"id":4165,"depth":274,"text":4166},{"id":4178,"depth":274,"text":4179},{"id":4191,"depth":274,"text":4192},{"id":4204,"depth":274,"text":4205},{"date":4232,"author":287,"headerImage":4233},"2025-04-14","\u002Fimages\u002Fblog\u002Ftools.jpg","\u002Fblog\u002Fwhy-i-built-wanderer",{"title":4113,"description":4118},{"loc":4234},"blog\u002Fwhy-i-built-wanderer","3tbx5hlCypfJTtLoqx4gkvW95AmR2cG9Cd_yvdhqGtE",{"id":4240,"title":4241,"body":4242,"description":4246,"extension":284,"meta":4447,"navigation":289,"path":4450,"seo":4451,"sitemap":4452,"stem":4453,"__hash__":4454},"blog\u002Fblog\u002Fwhy-conversations-dont-fit-into-trees.md","Why Conversations Don’t Fit Into Trees",{"type":8,"value":4243,"toc":4435},[4244,4247,4252,4256,4259,4262,4276,4282,4286,4289,4293,4296,4302,4306,4309,4312,4315,4319,4322,4329,4333,4336,4342,4346,4353,4360,4364,4371,4382,4387,4391,4394,4416,4419,4424,4429],[11,4245,4246],{},"Many chatbot builders still treat conversations like decision trees. This may seem logical at first but it quickly leads to inflexible designs, messy edge cases, and unnecessary programming.",[1211,4248,4249],{},[11,4250,4251],{},"Real conversations are not trees. They’re networks. And that changes everything.",[24,4253,4255],{"id":4254},"why-trees-fall-short","Why Trees Fall Short",[11,4257,4258],{},"You’ve probably seen it before: a chatbot builder that uses a tree-like layout to map out conversations. It looks clean... until it doesn’t. Real conversations don’t follow such strict branching logic.",[11,4260,4261],{},"In reality, they:",[35,4263,4264,4267,4270,4273],{},[38,4265,4266],{},"Loop back.",[38,4268,4269],{},"Converge at conclusions.",[38,4271,4272],{},"Depend on multiple conditions.",[38,4274,4275],{},"Reuse earlier answers.",[11,4277,4278,4279,203],{},"This isn't just a technical issue - it's a ",[42,4280,4281],{},"modeling problem",[24,4283,4285],{"id":4284},"five-patterns-that-may-or-may-not-fit-into-a-tree","Five Patterns That May (or May Not) Fit Into a Tree",[11,4287,4288],{},"Let’s look at common conversational patterns and where tree structures begin to fail.",[820,4290,4292],{"id":4291},"_1-sequential-question-chains","1. Sequential Question Chains",[11,4294,4295],{},"Simple back-to-back questions. Great for onboarding or form-filling.",[11,4297,4298,4301],{},[42,4299,4300],{},"Trees can handle this."," No logic needed.",[820,4303,4305],{"id":4304},"_2-classic-tree-branches","2. Classic Tree Branches",[11,4307,4308],{},"This is where many builders stop. A question leads to answers, each branching out into new paths.",[11,4310,4311],{},"But what if questions should come back together? Or what if later questions depend on multiple earlier answers?",[11,4313,4314],{},"Trees can’t do that well.",[820,4316,4318],{"id":4317},"_3-diamond-shapes-merging-paths","3. Diamond Shapes (Merging Paths)",[11,4320,4321],{},"Multiple branches converging into a shared conclusion - like forming a diagnosis or summarizing intent.",[11,4323,4324,4325,4328],{},"This ",[42,4326,4327],{},"requires a network",", not a tree. In trees, merged logic often means messy hacks or hidden condition checks.",[820,4330,4332],{"id":4331},"_4-complex-conversation-networks","4. Complex Conversation Networks",[11,4334,4335],{},"By combining chains, trees, diamonds, and loops, you get flexible conversation flows that mirror real-life interactions.",[11,4337,4338,4339,4341],{},"This is what ",[42,4340,398],{}," is built for.",[820,4343,4345],{"id":4344},"_5-deep-contextual-conclusions","5. Deep Contextual Conclusions",[11,4347,4348,4349,4352],{},"Sometimes outcomes depend on ",[382,4350,4351],{},"several"," conditions across different branches. This can’t be represented cleanly in a tree.",[11,4354,4355,4356,4359],{},"Instead, it needs ",[42,4357,4358],{},"graph-based logic",", where multiple edges feed into a single conclusion node with clear, testable conditions.",[24,4361,4363],{"id":4362},"the-tree-is-only-the-path-not-the-map","The Tree Is Only the Path, Not the Map",[11,4365,4366,4367,4370],{},"Here’s the trick: when a conversation happens in real time, the path a user takes ",[382,4368,4369],{},"can"," look like a tree.",[11,4372,4373,4374,4377,4378,4381],{},"But the ",[42,4375,4376],{},"system"," underneath should still be a ",[42,4379,4380],{},"network"," with all paths, logic gates, and alternatives in place.",[1211,4383,4384],{},[11,4385,4386],{},"A user’s journey is a tree. But your logic should live in a network.",[24,4388,4390],{"id":4389},"why-wanderer-is-built-as-a-graph","Why Wanderer Is Built as a Graph",[11,4392,4393],{},"Wanderer embraces the full complexity of conversations:",[35,4395,4396,4403,4406,4413],{},[38,4397,4398,4399,4402],{},"Logic lives in ",[42,4400,4401],{},"edges",", not hidden in code.",[38,4404,4405],{},"You can combine patterns freely: trees, diamonds, loops.",[38,4407,4408,4409,4412],{},"The flow remains ",[42,4410,4411],{},"visual, transparent, and editable"," at all times.",[38,4414,4415],{},"Conversations evolve dynamically with real-time state logic.",[11,4417,4418],{},"Whether you're building a chatbot, survey, or interactive guide your users deserve more than a decision tree.",[11,4420,4421],{},[42,4422,4423],{},"Let’s give them a real conversation.",[11,4425,4426],{},[172,4427,2824],{"href":2822,"rel":4428},[176],[11,4430,267,4431],{},[172,4432,4433],{"href":4433,"rel":4434},"https:\u002F\u002Fpixabay.com\u002Fde\u002Fphotos\u002Fbaum-natur-holz-kahler-baum-stamm-3097419\u002F",[176],{"title":273,"searchDepth":274,"depth":274,"links":4436},[4437,4438,4445,4446],{"id":4254,"depth":274,"text":4255},{"id":4284,"depth":274,"text":4285,"children":4439},[4440,4441,4442,4443,4444],{"id":4291,"depth":1031,"text":4292},{"id":4304,"depth":1031,"text":4305},{"id":4317,"depth":1031,"text":4318},{"id":4331,"depth":1031,"text":4332},{"id":4344,"depth":1031,"text":4345},{"id":4362,"depth":274,"text":4363},{"id":4389,"depth":274,"text":4390},{"date":4448,"author":287,"headerImage":4449},"2025-04-02","\u002Fimages\u002Fblog\u002Ftree.jpg","\u002Fblog\u002Fwhy-conversations-dont-fit-into-trees",{"title":4241,"description":4246},{"loc":4450},"blog\u002Fwhy-conversations-dont-fit-into-trees","RHWcutyREx07NxLrEwSDC16W4EpJiHFkX2bjy5ykeXY",{"id":4456,"title":4457,"body":4458,"description":4462,"extension":284,"meta":4854,"navigation":289,"path":4857,"seo":4858,"sitemap":4859,"stem":4860,"__hash__":4861},"blog\u002Fblog\u002Fwhy-conversations-dont-belong-in-relational-databases.md","Why Conversations Don't Belong in Relational Databases",{"type":8,"value":4459,"toc":4839},[4460,4463,4468,4471,4475,4478,4481,4495,4498,4502,4505,4516,4519,4538,4541,4546,4584,4589,4622,4626,4699,4706,4717,4721,4727,4730,4738,4744,4748,4751,4769,4772,4786,4797,4801,4811,4814,4818,4825,4828,4833],[11,4461,4462],{},"When building chatbot platforms or conversational agents, developers often try to store conversation logic in relational or document-based databases. But here’s the problem:",[1211,4464,4465],{},[11,4466,4467],{},"Conversations aren’t tables. They’re networks.",[11,4469,4470],{},"This article explores why traditional databases struggle with conversation modeling and why Wanderer takes a different path using graphs.",[24,4472,4474],{"id":4473},"tables-are-for-structured-data-conversations-arent","Tables Are for Structured Data. Conversations Aren’t.",[11,4476,4477],{},"Relational databases are great when your data fits into predictable rows and columns think products, invoices, users. This is the basis for CRUD apps (Create, Read, Update, Delete) and admin panels.",[11,4479,4480],{},"But conversations aren't structured like spreadsheets. They're full of:",[35,4482,4483,4486,4489,4492],{},[38,4484,4485],{},"Conditional paths",[38,4487,4488],{},"Branching questions",[38,4490,4491],{},"Loops and returns",[38,4493,4494],{},"Deep context dependencies",[11,4496,4497],{},"Trying to force this into a tabular model means you're constantly writing glue code to simulate logic that just doesn’t belong there.",[24,4499,4501],{"id":4500},"lets-try-it-anyway","Let’s Try It Anyway…",[11,4503,4504],{},"Imagine trying to store a conversation like this:",[743,4506,4507,4510,4513],{},[38,4508,4509],{},"A user is greeted with a question.",[38,4511,4512],{},"Depending on their answer, the bot either asks a follow-up, jumps to another branch, or ends.",[38,4514,4515],{},"Some answers lead to the same node. Others diverge. Some depend on earlier context.",[11,4517,4518],{},"In a relational model, you'd need:",[35,4520,4521,4526,4531],{},[38,4522,504,4523],{},[42,4524,4525],{},"questions table",[38,4527,504,4528],{},[42,4529,4530],{},"suggestions (answers) table",[38,4532,4533,4534,4537],{},"An ",[42,4535,4536],{},"edges table"," connecting questions and answers with conditions",[11,4539,4540],{},"Here’s a simplified version:",[820,4542,4544,1681],{"id":4543},"questions",[1206,4545,4543],{},[1441,4547,4548,4558],{},[1444,4549,4550],{},[1447,4551,4552,4555],{},[1450,4553,4554],{},"id",[1450,4556,4557],{},"label",[1476,4559,4560,4568,4576],{},[1447,4561,4562,4565],{},[1481,4563,4564],{},"1",[1481,4566,4567],{},"Hey! How are you?",[1447,4569,4570,4573],{},[1481,4571,4572],{},"2",[1481,4574,4575],{},"Why are you stressed?",[1447,4577,4578,4581],{},[1481,4579,4580],{},"3",[1481,4582,4583],{},"What do you want to do?",[820,4585,4587,1681],{"id":4586},"suggestions",[1206,4588,4586],{},[1441,4590,4591,4599],{},[1444,4592,4593],{},[1447,4594,4595,4597],{},[1450,4596,4554],{},[1450,4598,4557],{},[1476,4600,4601,4608,4615],{},[1447,4602,4603,4605],{},[1481,4604,4564],{},[1481,4606,4607],{},"I'm fine",[1447,4609,4610,4612],{},[1481,4611,4572],{},[1481,4613,4614],{},"I'm stressed",[1447,4616,4617,4619],{},[1481,4618,4580],{},[1481,4620,4621],{},"Book a holiday",[820,4623,4624,1681],{"id":4401},[1206,4625,4401],{},[1441,4627,4628,4646],{},[1444,4629,4630],{},[1447,4631,4632,4634,4637,4640,4643],{},[1450,4633,4554],{},[1450,4635,4636],{},"from_type",[1450,4638,4639],{},"from_id",[1450,4641,4642],{},"to_type",[1450,4644,4645],{},"to_id",[1476,4647,4648,4662,4674,4686],{},[1447,4649,4650,4652,4655,4657,4660],{},[1481,4651,4564],{},[1481,4653,4654],{},"question",[1481,4656,4564],{},[1481,4658,4659],{},"suggestion",[1481,4661,4564],{},[1447,4663,4664,4666,4668,4670,4672],{},[1481,4665,4572],{},[1481,4667,4654],{},[1481,4669,4564],{},[1481,4671,4659],{},[1481,4673,4572],{},[1447,4675,4676,4678,4680,4682,4684],{},[1481,4677,4580],{},[1481,4679,4659],{},[1481,4681,4572],{},[1481,4683,4654],{},[1481,4685,4572],{},[1447,4687,4688,4691,4693,4695,4697],{},[1481,4689,4690],{},"4",[1481,4692,4654],{},[1481,4694,4572],{},[1481,4696,4659],{},[1481,4698,4580],{},[11,4700,4701,4702,4705],{},"It ",[382,4703,4704],{},"works"," but only in theory. As your flows grow, the model becomes unmanageable.",[35,4707,4708,4711,4714],{},[38,4709,4710],{},"You’d need recursive queries or stored procedures to resolve the next valid step.",[38,4712,4713],{},"You’d constantly join and filter across multiple tables.",[38,4715,4716],{},"Traversing the logic visually or debugging it becomes nearly impossible.",[24,4718,4720],{"id":4719},"document-stores-arent-much-better","Document Stores Aren’t Much Better",[11,4722,4723,4724,203],{},"MongoDB and other document databases offer more flexibility. But you still face the same challenge: ",[42,4725,4726],{},"relationships",[11,4728,4729],{},"You can either:",[35,4731,4732,4735],{},[38,4733,4734],{},"Nest everything (but then reuse becomes difficult), or",[38,4736,4737],{},"Reference everything (but then querying and joining gets ugly again)",[11,4739,4740,4741,203],{},"In short: neither tabular nor document structures naturally express ",[42,4742,4743],{},"networks",[24,4745,4747],{"id":4746},"conversations-are-graphs","Conversations Are Graphs",[11,4749,4750],{},"At Wanderer, we treat every flow as a graph:",[35,4752,4753,4758,4763],{},[38,4754,4755,4757],{},[42,4756,2576],{}," represent questions, messages, actions, etc.",[38,4759,4760,4762],{},[42,4761,2582],{}," represent the logic between them - may, must, not, push, call.",[38,4764,4765,4768],{},[42,4766,4767],{},"States"," flow through the system, triggering changes based on edge logic.",[11,4770,4771],{},"This allows us to:",[35,4773,4774,4777,4780,4783],{},[38,4775,4776],{},"Model even the most complex conversational structures",[38,4778,4779],{},"Visualize flows clearly, with every logical condition visible",[38,4781,4782],{},"Traverse the graph deterministically or reactively",[38,4784,4785],{},"Store and share flows as clean, portable JSON",[1211,4787,4788],{},[11,4789,4790,4791,4793,4794,4796],{},"In a graph, your data ",[382,4792,384],{}," your logic. And your logic ",[382,4795,384],{}," visual.",[24,4798,4800],{"id":4799},"from-theory-to-practice","From Theory to Practice",[11,4802,4803,4804,4807,4808,4810],{},"With Wanderer, the conversation graph ",[42,4805,4806],{},"is the database",". The flow you draw ",[382,4809,384],{}," what gets saved. There’s no translation layer, no hidden logic, and no mismatch between front-end and back-end.",[11,4812,4813],{},"And best of all: it runs entirely in the browser.",[24,4815,4817],{"id":4816},"final-thoughts","Final Thoughts",[11,4819,4820,4821,4824],{},"Relational and document databases were never designed for conversational logic. The more you try to force it, the more complexity you create. Wanderer embraces the true structure of conversations ",[42,4822,4823],{},"as networks"," and makes them visible, editable, and executable.",[11,4826,4827],{},"If you’re tired of fighting against your database schema, try building with the graph instead.",[11,4829,4830],{},[172,4831,2824],{"href":2822,"rel":4832},[176],[11,4834,267,4835],{},[172,4836,4837],{"href":4837,"rel":4838},"https:\u002F\u002Fpixabay.com\u002Fde\u002Fphotos\u002Fkarten-katalog-schubladen-holz-194280\u002F",[176],{"title":273,"searchDepth":274,"depth":274,"links":4840},[4841,4842,4850,4851,4852,4853],{"id":4473,"depth":274,"text":4474},{"id":4500,"depth":274,"text":4501,"children":4843},[4844,4846,4848],{"id":4543,"depth":1031,"text":4845},"questions:",{"id":4586,"depth":1031,"text":4847},"suggestions:",{"id":4401,"depth":1031,"text":4849},"edges:",{"id":4719,"depth":274,"text":4720},{"id":4746,"depth":274,"text":4747},{"id":4799,"depth":274,"text":4800},{"id":4816,"depth":274,"text":4817},{"date":4855,"author":287,"headerImage":4856},"2025-03-17","\u002Fimages\u002Fblog\u002Fdatabase.jpg","\u002Fblog\u002Fwhy-conversations-dont-belong-in-relational-databases",{"title":4457,"description":4462},{"loc":4857},"blog\u002Fwhy-conversations-dont-belong-in-relational-databases","3pokrt9aSkIES5LUAEmCMrn1GwiWsLqXz1ekGlcknlI",1786889213568]