Most teams start with one prompt and then hit the same wall: the assistant works in demos, but becomes inconsistent as tasks get more complex. Patterns are what help you get past that wall.
This guide covers the core agent patterns teams use in production and shows how they translate into Kemu recipes. Each pattern section includes a recipe link you can try directly, so you can experiment with real workflows and decide which approach fits your use case.
This post adapts ideas from a Google developer video on agent patterns, and shows how they map to Kemu recipes.
Single Agent Pattern
If you are new to agent workflows, this is the simplest place to start.
A single agent receives a request, reasons about it, optionally uses tools, and returns an answer. No handoffs, no orchestration graph, no extra coordination logic. Just a straightforward path from input to output.
This pattern works well for tasks like summarization, extraction, and straightforward Q&A where one reasoning loop is enough. Keep it simple until you have a reason not to.
Example in Kemu (Document Summarizer)
Use one AI Agent recipe that takes a document URL and returns a short summary.
In Kemu, this is easy to wire because you can connect input directly to one agent and stream the response to output widgets for quick testing.
Sequential Pattern
Sequential workflows split one task into ordered stages. Each stage has a narrow responsibility, and the next stage receives the previous result.
This pattern is useful when quality matters more than speed because you can inspect each step and see exactly where output quality drops. When something goes wrong, you know which stage to fix.
Example in Kemu (Planner -> Writer -> Editor)
Turn one topic into a polished article by chaining three agents:
- Planner creates a structured outline.
- Writer expands it into a full draft.
- Editor improves clarity and consistency.
In Kemu, this works well because each handoff can be inspected in the canvas and adjusted independently.
Parallel Pattern
Parallel workflows split one request into independent subtasks that run at the same time, then merge results.
Use this when tasks do not depend on each other and latency matters. The catch is that you need a good synthesizer agent that can combine partial answers into something coherent.
Example in Kemu (Parallel Research + Synthesis)
For a launch decision, run three agents in parallel:
- Market demand
- Competitive landscape
- Risk and constraints
Then pass all three outputs into one synthesizer agent that creates the final recommendation.
In Kemu, the fan out and merge are visual, which makes this pattern easier to reason about than in pure code.
How to Choose
With all three patterns introduced, the comparison is straightforward:
- Single: best starting point, lowest complexity
- Sequential: best control and quality tuning
- Parallel: best latency for independent tasks
Most teams start with Single, move to Sequential when quality control becomes important, and use Parallel when they need faster results from independent workstreams.
Final Takeaway
Patterns are what turn "an LLM call" into a reliable system design.
Kemu helps because each pattern can be expressed as a recipe you can see, test, and improve quickly. Once the team agrees on pattern choice first, implementation gets much easier. Often you can just export the recipe and run it as a standalone Node.js application.
Choose your agent pattern in Kemu now and see how quickly a prompt becomes a dependable workflow.
Ready to get started with Kemu?
Build your own computer vision solutions without writing code. Start creating powerful ML and machine vision pipelines today.