Coordinate occurrences

Every trigger occurrence starts a root context. A cross-context operator selects occurrences and creates a child context containing their parent histories.

Result	Operators
Run the same flow for every occurrence from several triggers	`merge`
Join related events from different triggers	`keyBy`, then `correlate`
Batch a fixed number of occurrences	`keyBy` or `globally`, then `collect`
Admit once or a bounded number of times	`once` or `take`
Enforce a rolling quota	`rateLimit`
Run one section per item already in an array	`each`
Prevent overlapping work for one partition	`serialize`
Bound overlapping work for one partition	`concurrent`
Time or buffer a burst	Control event bursts

Partition the streams

Use keyBy when each customer, record, conversation, or other business key needs its own coordination state. Use globally only when every occurrence should enter one shared batch or timer.

automations/match-decisions.automation.ts

import { automation, correlate, onInvocation, sendEmail, t } from "automate.ax"

export default automation("Match approval decisions", () => {
  const request = onInvocation<{ id: string; title: string }>("request").keyBy(
    (value) => value.id,
  )
  const decision = onInvocation<{ requestId: string; status: string }>(
    "decision",
  ).keyBy((value) => value.requestId)

  correlate([request, decision])
  sendEmail({
    subject: t`Decision for ${request.title}`,
    text: t`The decision was ${decision.status}.`,
  })
})

The email can consume both original signals because the correlation child is their closest shared boundary.

Merge independent triggers

Use merge when every occurrence should continue independently through the same flow. Unlike correlate, it doesn’t wait for another stream or consume occurrences in pairs.

automations/process-contact-events.automation.ts

import {
  automation,
  merge,
  onInvocation,
  sendEmail,
  serialize,
  t,
} from "automate.ax"

interface ContactEvent {
  contactId: string
  user: string
}

export default automation("Process contact events", () => {
  const created = onInvocation<ContactEvent>("contactCreated")
  const updated = onInvocation<ContactEvent>("contactUpdated")
  const contactEvent = merge([created, updated])

  serialize(
    contactEvent.keyBy((event) => event.user),
    () => {
      sendEmail({
        subject: t`Contact ${contactEvent.contactId} changed`,
        text: t`Processing the change for ${contactEvent.user}.`,
        to: "operations@example.com",
      })
    },
  )
})

Here the merged signal supplies each queued occurrence, the user key creates one queue per user, and the signal’s value remains available inside the serialized section. Two actions declared inside the section without a dependency on each other would still run concurrently. The next event for that user waits for the entire section’s work region to close; events for other users don’t wait. Value-preserving operators retain a keyed or global annotation. Arbitrary derivations and multi-input selections can return an ordinary signal; apply keyBy or globally again before another cross-context operation.

Choose an identity and time

Prefer a provider’s entity or conversation ID when it expresses the relationship. Use correlationId when you need a stable opaque identity for one durable occurrence. Use timestamp when you need Automate.ax ingestion, completion, or coordination time instead of a provider timestamp.

Batch or fan out

Use collect when a count closes the group. The result is a nonempty array in arrival order. Use each when one existing array should create a durable child context per item; return a signal from the section only when you need to gather the per-item results.

Start

Concepts

Guides

Coordinate occurrences

Partition the streams

Merge independent triggers

Choose an identity and time

Batch or fan out

​Partition the streams

​Merge independent triggers

​Choose an identity and time

​Batch or fan out

Partition the streams

Merge independent triggers

Choose an identity and time

Batch or fan out