Product updates

Deterministic when you can, AI when you must

Halil İbrahim Kalkan10 min read

Illustration: a fading canvas of boxes and arrows behind a code editor, where one highlighted line is the single model call, feeding a run whose steps are all checked off.

Every Monday, someone on your team reads the week's tasks, checks which pull requests are still open, and writes the same update they wrote last Monday. Everyone agrees this job should be automated. The disagreement is about how.

For years the answer was a canvas: boxes and arrows, drawn once, followed forever. Then agents arrived, and many teams swung the other way: describe the process to a model and let it decide what happens next. Volobox gives you a third option, and we think it is what most recurring processes actually need.

The question that matters: who decides the next step?

Every automation tool answers it, usually without saying so.

  • On a canvas, the author decides, ahead of time, by drawing every path.
  • In a playbook, the model decides, at every step, by reading your instructions.
  • In a Code workflow, your code decides. The model is one step you call on purpose, for the parts that need language or judgement.

Each answer suits some kinds of work. The trouble starts when one answer is forced on all of it.

Canvases are great to look at, and hard to live in

A canvas shows the shape of a process at a glance. That is its real strength. But a canvas that runs real processes keeps growing: an if node, a loop node, a code node, a small expression language, variables with a scope. Over time it turns into a programming language, except you can't read a change as a diff, test it, or work on it with three colleagues at once. And once you drop an "AI agent" node into it, the fixed path the canvas promised is gone.

So Volobox has no node editor, on purpose. We kept the picture, the one part of the canvas worth keeping, and reversed which side you write. More on that below.

Playbooks: when judgement is the job

A Volobox playbook is a process written in plain markdown. An agent reads it, uses your workspace tools, asks a person when it needs a decision, waits for replies or timers, and carries on. It fits work that has to adapt to what it finds: a request nobody words the same way twice, meeting notes that need to become tasks, a customer message whose real question takes reading to find. You write the rules the way you would brief a colleague, and anyone on the team can read them.

That flexibility has a price, and better prompts won't remove it. In a playbook, the model sits between every two steps. Filtering a list, counting open tasks, noticing that nothing happened this week: each one is a model turn you pay for and wait for, and each turn re-reads a conversation that grows with every tool result. Two runs on the same data can also take slightly different paths, because the model reads your rules fresh each time. A better playbook makes this smaller. It can't make it go away, because it comes from how a playbook runs.

Code workflows: the model as one step you call on purpose

A Code workflow keeps everything around the process: the same triggers, typed inputs, skills, approvals, access rules and run history. Only the body changes. Instead of markdown an agent interprets, the body is JavaScript that Volobox runs on the server. It calls your workspace tools directly, makes decisions with ordinary if statements, and calls the model with ai.generate only where language or judgement is really needed.

Here is the Monday report, shortened from the Weekly status report (code) template:

const tasks = await tools.list_project_tasks({ projectId: inputs.project_id });
const page = await tools.list_project_pull_requests({ projectId: inputs.project_id });
const pullRequests = page.items ?? [];

if (tasks.length === 0 && pullRequests.length === 0) {
  // A quiet week is a fact, not a failure, and it does not need a model to say so.
  await tools.send_message({ targetKind: 'Project', targetId: inputs.project_id, body: 'No open work on this project this week.' });
  await wf.complete('Reported a quiet week.');
}

const report = await ai.generate(
  'Write a weekly project update for the team, under 200 words: Shipped, In flight, Needs attention.',
  { context: { tasks, pullRequests }, schema: { type: 'object', properties: { markdown: { type: 'string' } } } }
);

await tools.send_message({ targetKind: 'Project', targetId: inputs.project_id, body: report.markdown });

That one change gives you three things at once.

Cheaper

The model is the expensive part of an automated run, and a Code workflow calls it only where you wrote ai.generate. Reading three lists costs nothing in AI. A quiet week costs nothing at all. Some processes never need a model: the Tell everyone with an expertise template sends your message to every available person who declares that expertise, with no model call anywhere. And when the model does run, it gets one prompt with exactly the fields it needs, not a long conversation full of raw tool output.

You don't have to take our word for it. When you convert a playbook to code, the workflow's Stats tab puts both versions side by side: what a run typically costs and how many model calls it makes, for the playbook runs before the conversion and the code runs after. It shows a comparison only once each side has enough completed runs for it to mean something.

Faster

In a Code workflow, tool calls run back to back. No model turn sits between them deciding what comes next. In an agent run, most of the time goes to waiting on the model. Here that wait happens once, at the end, over data that has already been gathered.

Deterministic

Same input, same path, every time. The body is ordinary code, so a rule like "a finished task never gets a deadline warning" is an if, not a sentence the model has to remember. Volobox builds the rest into the runtime: Math.random() is refused, and "now" is fixed to the moment the run started, so a resumed run takes the same path it took the first time. The body has a version history, and every run names the version it ran, so when someone asks "why did it do that?", the answer is one click away.

Deterministic doesn't mean simple. A Code workflow can wait for a timer, for someone's reply, for an approval, or for a coding run to finish, even if that takes days. While it waits, nothing is held open. When the wait is over, Volobox runs the body again from the top, answers every call it already made from its record, and carries on from the next line. Nothing before the wait happens twice.

The picture, drawn from the code

Remember the one thing a canvas does well? Volobox keeps it, the other way around. You don't draw a diagram to describe the process. You write the process, and Volobox draws the diagram.

The Storyboard lays out a Code workflow step by step: its phases, tool calls, model steps, waits, approvals, and where the run ends. At a glance sums up what starts the workflow and what it reads, writes and waits on. Once runs have finished, the Storyboard also shows what they did: how often each step ran, which branch no run has reached, and where a failed run stopped. Playbooks get the same views, read from their markdown. The picture is built from the body itself, so it always matches what runs.

You don't need to be a developer, or decide up front

An exact process calls for code. That doesn't mean the person behind it has to be a developer.

  • Fill with AI writes the body from a description. Every change it proposes is checked against the workflow's real tools and permissions before it reaches the editor, so it can't hand you code that won't save.
  • Problems show up before you save: a misspelled tool, a tool the workflow isn't allowed to use, or a model call inside a loop that would multiply the cost.
  • Rehearse a run first. It reads for real and records every write it would make instead of making it.
  • Start as a playbook. Once a process has settled into doing the same thing every time, Convert to code turns it into a Code workflow in place, keeping its triggers, inputs, access and run history. The assistant lists the steps it left to the model and the questions it couldn't answer, which is where a person should look first.

Several templates come in both versions, including the weekly status report, due date risk, request triage and pull request watch, so you can compare the playbook and the code before you choose. The AI delivery templates, which take an agent's work from a task to a reviewed pull request, are Code workflows too.

The idea helps inside a playbook as well. When a step means calling several tools and boiling the results down, the agent can write a short code step that does it in one go, and the intermediate results never pass through the model. The calls inside it keep their usual permissions, limits and log entries.

Match the shape to the work

Asking which tool is best gets you nowhere. Ask who should decide the next step, and expect the answer to change from one process to the next. Some work needs judgement, and a playbook is the right home for it. A lot of work, more than most teams expect, is a set of rules nobody has written down yet. Write them down, call the model where it earns its place, and let the rest run the same way every time: cheaper, faster, and predictable enough to trust.

Volobox is built by the team behind the ABP Framework. More on workflows is on the product page. If your team has a process that runs every week, request a demo and bring it along. We will show you both versions of it.

Bring a process that runs every week

In the demo we take one of your recurring processes and show it as a playbook and as a Code workflow, side by side.