> ## Documentation Index
> Fetch the complete documentation index at: https://docs.automate.ax/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Automate.ax automations are TypeScript programs.
> Use Bun for installation and command examples.
> Use Automate.ax for the product name and automate.ax for the package, CLI, and domain.
> Treat documented public APIs as current; do not invent transitional or deprecated names.

# Actions

> Perform durable work with typed inputs, outputs, and dependencies.

An action performs one unit of work: call an integration, update a message,
transform data, emit a response, or produce another value.

```ts theme={null}
const message = getMessage({ messageId: email.messageId })

log({ value: message.subject })
```

Calling an action registers its invocation and returns a `Signal` for the
eventual output. Automate.ax resolves its inputs, validates them, executes the
action, validates its output, and then makes that output available to dependent
work.

## Inputs

Action inputs are typed object properties. Each property accepts a direct value
or a compatible signal:

```ts theme={null}
sendEmail({
  to: "person@example.com",
  subject: email.subject,
  text: "We received your message.",
})
```

Here, `to` and `text` are literal values. `subject` is a signal, so the action
waits for the incoming email before executing.

Defaults and validation belong to the action's schema. The action reference
documents each field, limit, and provider-specific rule.

## Outputs

An action's return value is always a signal, even when its eventual output is
an object, array, primitive, or `void`.

```ts theme={null}
const sent = sendEmail({
  to: "person@example.com",
  subject: "Status update",
  text: "Processing finished.",
})

log({ value: sent.messageId })
```

Property access keeps the output typed while recording the dependency.

## Concurrency and ordering

Actions become ready when all their signal inputs and inherited dependencies
are ready. Two calls that depend only on the same trigger can execute
concurrently. Passing one action's output to another establishes ordering.

Do not add a fake data dependency just to control order. When work must wait
without consuming a value, use `group(dependency, fn)` to add an explicit
dependency to the actions called inside the function.

## Failures

When an action fails, ordinary dependent actions do not execute. Independent
branches can continue. Use `failed(actionSignal)` when another action should
handle the failure as data.

Action execution may be retried by the platform. Integration actions are
designed around their provider's behavior, but an automation should not assume
that several separate actions form one transaction.

## Integration actions

Account-backed actions declare the service and permissions they require.
Automate.ax resolves the selected [integration
account](/concepts/integration-accounts) only when the action executes; provider
credentials never appear in action inputs or signals.

Browse the [Actions reference](/reference/actions) for available operations.