The automation builder

Describe it in a sentence. Ship it as a plan you can read.

Write what you want in plain English. Nuntilo compiles it into a visual trigger → condition → action plan — one you review, test against real events, and arm only when you're satisfied. No YAML, no drag-and-drop maze, no black box.

Prose in, plan out

Say it like you'd say it to a coworker.

You write the intent; Nuntilo does the wiring. It reads your sentence, maps it onto the events and actions your business actually has, and lays out a plan as a graph you can see. Nothing arms until you approve it — the compile step is a proposal, not a commit.

  • “When CI fails on main, tell #ops — at most once an hour.”
  • Compiled into named trigger → condition → action rules.
  • Every plan comes with a confidence score before you commit.
Test

Simulate an event — the same judgment the live wheel runs, no side effects.

github.workflow_failed{ branch: "main" }
Notify ops on CI failurewould fire
  • ✓branch == main
  • ✓conclusion == failure

Would deliver

#ops — “CI failed on main · build #4821”

The test loop

Dry-run an event. See exactly what would happen.

This is the part developers ask about first. Before an automation touches anything real, you simulate an event through it and get a clause-by-clause trace: what matched, what didn't, whether it would fire, and the exact message it would send. And because the test harness runs the very same rule engine as production — not a lookalike — a green test means the live path is green too.

  • Feed a rule a sample event and watch it evaluate, clause by clause.
  • See the literal delivery each rule would send — before it sends anything.
  • The dry-run uses the same evaluator as the live wheel. A test can't drift from production.

Expressive without a language to learn

Simple by default. Precise when you need it.

The plain-English layer covers the common cases. Underneath, the rule model is genuinely expressive — so the hard automation is still one plan away.

Match precisely

Real conditions

Operators (gt, contains, in), any/all/not groups, and dot-paths into the payload.

Control the noise

Cooldowns & thresholds

“At most once an hour,” or “only after three in a day” — rate limits and windowed counts are first-class.

Compose steps

Chaining

When a rule fires, it raises its own event — so one automation can trigger the next, and multi-step flows just fall out.

Say the right thing

Templated actions

Pull fields straight from the event into the message: {{payload.branch}}.

On a clock

Scheduled events

A built-in hourly tick means “every morning” or “each hour” automations need no external cron.

Beyond keywords

Learned extraction

Conditions can match on what Nuntilo understood a message to be about — topic, intent — not just its raw fields.

The gate

Auto where it's safe. Your sign-off where it counts.

Every action carries a gate. Notifying your own team can fire on its own; creating a public issue, emailing a customer, or publishing release notes waits for you. Nuntilo drafts it, holds it, and asks — so automation never means handing over the decisions that carry your name.

  • Low-stakes actions (post to Slack, log a lead) just run.
  • Anything customer-facing parks at the gate for your approval — with a timeout you set.
  • Approve, edit, or decline from the web or your phone.
Nuntilo

Marcus asked for references. I've drafted a reply with the three you usually send. Send it?

See the trail

  1. Event

    github.workflow_failed received

  2. Synthesis

    matches “Notify ops on CI failure”

  3. Gate

    auto — confidence 0.91 over threshold

  4. Reaction

    posted to #ops

Nothing unaccountable

Every automation leaves a trail.

Automation you can't inspect is automation you can't trust. Every run records an append-only trail — the triggering event, which rule matched, how confident Nuntilo was, whether it gated, and what it did. “See the trail” is one click from anything that happened.

  • See why a rule fired — the event, the match, the confidence, the result.
  • Each stage is recorded: event → decision → gate → action.
  • When something looks off, you can read exactly what Nuntilo decided and why.
The plan is readable, the test can't lie, and the gate is yours. That's the whole contract.
Why the builder works this way

Built for the tools developers already live in — GitHub, Slack, and Linear — with more on the way. See Nuntilo for developers.

Automate the plan you can actually read.

Join the waitlist and we'll reach out as Nuntilo opens to early businesses.