When you ask a chatbot a complex question, most of them do the same thing under the hood: one big AI call, one block of text back. That's fine for "what's the capital of France". It's a poor fit for the way people actually ask for things — because a single sentence often hides several different jobs.

Synaplan handles those the way a good assistant would: it makes a quick plan, then does the steps.

One sentence, two jobs

Here's a request we use all the time:

"Can you create a short paragraph about DAG routing in AI models and create a reminder calendar entry for tomorrow at 10am?"

Read it again and you'll spot two completely different jobs in one sentence: write some text, and produce a calendar file. A normal chatbot has to fake both in a single answer. Synaplan instead draws a tiny plan with two steps — an Answer and a Calendar invite — and runs them while you watch each one tick over to Done. The calendar step hands you a real, downloadable .ics file for tomorrow at 10:00, with the date already worked out for you.

That's it on screen: a Task plan, two cards, both finished, one of them a downloadable meeting file. One prompt in, two real results out.

So what's a "DAG"?

DAG stands for Directed Acyclic Graph, which sounds far scarier than it is. Picture a little flowchart:

Boxes are steps ("write the paragraph", "make the calendar file").
Arrows mean this step feeds the next one (directed).
And the arrows never loop back on themselves (acyclic) — so the plan always finishes.

That's the whole idea. Instead of one giant prompt trying to do everything at once, an AI planner looks at your request and draws the boxes and arrows: which steps are needed, and which depend on which. Then Synaplan runs them in the right order — and where steps don't depend on each other (say, generating two images), it can run them at the same time.

Why this is genuinely useful

A plan beats a single call for three down-to-earth reasons:

One prompt, many real outputs. A single request can come back with several files — text, an image, a document, an .ics invite — not just one wall of text.
The right tool for each step. Need facts from your own documents? That step does a knowledge-base search. Need a picture? That step calls the image model. Need a meeting? That step builds the calendar file. Each job gets the tool that's actually good at it.
You can see it working. Every step shows up as its own card and moves from pending to running to done. No spinner-then-magic. If something fails, you see exactly which step, and the rest of the plan still delivers what it can.

Why it's a real gift if you self-host

This is where it gets interesting for teams, agencies, and public-sector organisations who run Synaplan on their own infrastructure.

It's your pipeline, on your hardware. The plan runs where your data already lives. Nothing is quietly shipped off to a black box you can't inspect — you can watch every step, and you decide which models (local Ollama, or a cloud provider) handle each one.
It's built to grow. Capabilities aren't hard-wired into one giant prompt; they're a tidy list the planner can pick from. Adding a new kind of step is a small, contained change — not a rewrite. Your platform can grow with what your team needs.
It keeps you in control. Transparent, step-by-step, auditable. For anyone who cares about digital sovereignty, "the AI showed its plan and ran it on our servers" is a very different story from "we sent everything to someone else's API and hoped".

What's next: open DAG endpoints for n8n and friends

Here's the part we're most excited about. Today every step in a plan is something Synaplan does itself. Next, we want to open the graph up.

We're working toward DAG endpoints — steps that hand off to the open-source tools you already run. The obvious first friend is n8n, the open-source automation platform: imagine the AI planning a request and one of its steps simply firing your existing n8n workflow — create the ticket, update the CRM, post to the channel — then folding the result back into the answer. Other open-source services will follow.

The split is the whole point: the AI does the planning; your tools do the work — on your infrastructure, under your rules. Instead of a closed assistant that can only do what its vendor allows, you get an AI front door to the self-hosted stack you've already built.

Try it

Multi-task routing is in Synaplan today. You can:

Self-host it: github.com/metadist/synaplan — docker compose up -d and you're running in a couple of minutes.
Read the deep dive: How DAG routing works — the planning model, the full set of capabilities, the live progress events, and the roadmap.
Turn it on: in the app, under Settings → Routing.

One prompt, a whole plan, running on your terms. That's the idea — and the open DAG endpoints are only going to make it more fun.