# Iris — workflows that run on your own machines when something happens · Astralyx

> Workflows triggered by webhooks, schedules or your own product calling them as an API: your models read the event, a box decides, you are told on your phone and Telegram, or a run starts on your GPUs. Durable, with approvals and error paths.

Source: https://astralyx.cloud/iris

Astralyx Iris · workflows, on all of Astralyx

# Something happens. _Your machines answer._

Iris joins boxes into workflows that run when something happens — your bank's webhook, an iPhone Shortcut, a camera system, your own product calling the workflow as an API, a time of day. A model of yours reads the event, a box decides, and you are told on your phone — or a run starts on your GPUs, or a person approves. Every execution survives a machine going away, and the models, data and functions stay on your machines.

[Open the console →](https://console.astralyx.cloud)[Read the docs](https://docs.astralyx.cloud/iris/)

What starts it

HTTP · time

A call to its own address, or a schedule. Or you, by hand, from anywhere.

A light box

Seconds

No container: a model, a function or a notice that is already up answers.

Finished boxes run again

Never

A machine going away loses nothing; the execution goes on from where it was.

Ways to write one

One object

The editor's boxes, YAML, the API, astra and Python all write the same workflow.

## An event in. Boxes that read it, decide, and act.

A workflow is boxes joined into a graph. Boxes that need each other run in order; the others run side by side. Each time it runs is an execution, drawn live in the console: every box's state, attempts and outputs.

01

#### Something happens

A call to the workflow's own address — a bank, a camera system, a Shortcut, your product — or a schedule. What arrived is the event, and every box reads its fields.

02

#### A model reads it

Ask a model: an Eos deployment or assistant of yours answers in text, or in the JSON fields you name — from a photo too. A function shapes the rest.

03

#### A box decides

Classify picks one of your labels, with how sure it is; a condition picks the way. Unsure, it says so, and a person can decide.

04

#### Something is done

You are told in the app, on your phone and on Telegram; a run starts on your GPUs; an agent works; a person approves. Called as an API, the caller gets the outputs.

## Drag boxes. Connect them. Every field stays yours.

In the console, boxes come from a palette — start, light, control, cluster — onto a graph; drag from one box to the next to connect them. Connect a box to a condition and it takes the condition's next way.

-   **Recipes**Each box offers ready answers — _Extract fields as JSON_, _Spending category_, _If / else_, _Workflow as an API_ — which fill its fields. Nothing is hidden: every field stays editable.
-   **One object**The graph and its YAML tab are the same workflow, and so is what the API, `astra iris workflows` and Python's `from astralyx.iris import Workflow` write.
-   **Checked**A workflow is checked before it is saved — a box that reads one it does not depend on, a loop, a name that is not in the workspace — and says what to fix.
-   **Versions**Every change is a new version that never changes; an execution keeps the one it started with.

card-spending.yamlYAML

```
metadata: { name: card-spending }
spec:
  inputs: [{ name: limit, default: "200" }]
  triggers:
    - { id: bank, kind: http, dedupe: "${{ event.id }}" }
  steps:
    - id: read
      kind: model
      assistant: money
      format: json
      prompt: "Amount and merchant, as JSON: ${{ event.text }}"
    - id: category
      kind: classify
      needs: [read]
      assistant: money
      input: "${{ steps.read.outputs.merchant }}"
      labels:
        - { name: food, description: "groceries, restaurants" }
        - { name: other, description: "anything else" }
    - id: big
      kind: switch
      needs: [read]
      cases:
        - { name: over, when: "steps.read.outputs.amount >= inputs.limit" }
    - id: tell
      kind: notify
      needs: [big, category]
      when: "steps.big.outputs.branch == 'over'"
      title: "${{ steps.read.outputs.merchant }}: over your limit"
```

your laptopshell

```
# The workflow as an API: the call waits
# and is answered with its outputs
$ curl -s "$ANSWER_ADDRESS" \
    -H "Authorization: Bearer $SECRET" \
    -d '{"question": "Capital of Australia?"}'
{"answer": "Canberra", "confidence": 0.98}

# By hand, with the event a trigger would send
$ astra iris workflows run card-spending \
    --event '{"id": "t1", "text": "$250.00 Corner Bakery"}' \
    --wait
```

## Its own address, or a time of day.

An HTTP trigger gives the workflow an address: anything that can send a request starts it — a bank's or a shop's webhook, a camera system, an iPhone Shortcut, a script, another product. A schedule starts it on time. And anyone who may can run it by hand: the console, `astra`, Python or the API.

-   **As an API**A call can wait for the execution — up to 90 seconds — and be answered with the workflow's outputs as JSON, in the same request. Or be answered at once, while it goes on.
-   **Proof**A secret in the address, a bearer token, or an HMAC signature of the body, as GitHub, Stripe and many banks sign their webhooks. The secret is shown once.
-   **Repeats**Senders retry. Name the event's id, and the same event sent again within your window — up to a day — starts one execution.
-   **Calls a minute**60 by default, up to 600; past it, a call is refused and told why.
-   **Schedules**Every so many minutes, or at a time of day on the days you choose, in your time zone. A time missed is run once, up to an hour late, or skipped and recorded — never once per time missed.

## Light where it can be. Your GPUs where it must be.

A light box is a call to what is already up — a model, a function, people's phones: seconds, no container, no machine to wait for. A cluster box is work placed on your machines, for as long as it takes.

Light · seconds, no container

model

#### Ask a model

An Eos deployment, or an assistant with its instructions, tools and memory. Text, or the JSON fields you ask for — each one an output the next boxes read. Photos too, for a model that sees.

classify

#### Classify

The model picks one of your labels, with a confidence and a reason. Below your threshold the label is uncertain, so a person can decide what a rule cannot.

function

#### Function

A function of the workspace, or code written right in the box — Python or Node. JSON in, JSON out, in milliseconds once it is up.

notify

#### Notify

A title and a message to the app's inbox, a push on the phone, and Telegram when the person linked it.

condition

#### Condition

If / else, or several ways: the first that holds is taken, and the boxes after it follow that way.

Cluster · containers on your machines

run

#### A run

Any container on your machines — GPUs, hours, many files — with the execution's drive, and outputs it writes as key=value lines.

agent

#### An agent

An Anemoi agent's run, under its policy, budgets and approvals, with its signed receipt listed in the execution.

workflow

#### A sub-workflow

Another workflow of the workspace, waited for, its outputs read as the box's.

[EOS

Ask a model and Classify use your deployments and assistants. A deployment scaled to zero is woken for the box.](https://astralyx.cloud/eos)[ANEMOI

The Agent box runs an agent of yours; Approval boxes are decided like any approval in the workspace.](https://astralyx.cloud/anemoi)[ASTRAEUS

Runs are queued and placed on your machines like any other; functions are the workspace's own.](https://astralyx.cloud/astraeus)[METIS

An assistant asked in a box brings the knowledge bases and memory you gave it, as it does in a chat.](https://astralyx.cloud/metis)[HESPERUSNext

A notebook as a box of a workflow.](https://astralyx.cloud/hesperus)

## People in the loop, where it matters.

Waiting for a person costs nothing: the workflow waits, and no machine is held meanwhile.

-   **Notify**The app's inbox, always; a push on the phone, unless it is the person's quiet hours; their Telegram when they linked it. Tapping the notice opens the execution.
-   **Approval**A person decides before the workflow goes on: approvers by role or by name, a day to decide by default, up to a week. Denied or not decided, the box fails.
-   **Wait for an event**The execution waits for an event sent to it — from its page, astra or the API — and reads its data as outputs. Or simply waits, a second to a week.
-   **Error path**A box that runs only when one before it fails: tell someone why, clean up. The execution still says it failed — an error path reports a failure, it never hides one.
-   **Uncertain**When Classify is not sure enough, its label is uncertain: a way of its own, to a notice or an approval, instead of a wrong guess acted on.

## It finishes what it started. Within the limits you set.

-   **A machine goes away**A run whose machine is lost is placed on another. Boxes already finished never run again; the execution goes on from where it was.
-   **A box fails**It is tried again — twice by default, up to ten times, with a pause you choose — and each box has its own time limit. Retry a failed box by hand, and the execution resumes from it.
-   **At once**Set how many executions run together. The others wait their turn, oldest first, or are refused — a caller is told the workflow is busy.
-   **Who it runs as**A person: whoever ran it, whoever made the trigger's address, or the workflow's owner for a schedule — with that person's access. When they lose it, their address stops working until someone who may makes it again.
-   **Within its workspace**Everything a workflow names — models, assistants, functions, agents, drives, other workflows — is of its own workspace; anything else is refused when it is written.
-   **From your assistant**In the app or on Telegram, your assistant runs a workflow you ask for and follows it; its result comes back to that chat. One that uses the machines waits for your confirmation. Over MCP, Claude, ChatGPT and Cursor do the same.

## Start from one that works.

Whole workflows, ready to use: pick one, choose the model or assistant it asks, and change any box. Each says what it needs from the workspace.

card-spending

#### Card spending

Your bank's purchase notice arrives; a model reads the amount and the merchant, a box files it in a category, and a purchase over your limit is told to you on your phone and Telegram.

health-report

#### Health report

Your phone's automation — an iPhone Shortcut — sends the day's numbers; your assistant reads them with what it remembers of you and answers on Telegram.

answer-api

#### Workflow as an API

A POST with a question waits for its answer: a condition checks the input, a model answers, and the call gets the outputs as JSON — in one request.

morning-brief

#### Morning brief

Every day at the time you choose, your assistant writes a short brief from your notes and memory and sends it to your phone.

with-error-path

#### A job with an error path

A container does the heavy part on your machines; if it fails, the box after it tells you why — and the workflow still says it failed.

[The recipes, step by step →](https://docs.astralyx.cloud/iris/recipes/)

## What stays on your machines.

The same rule as everything Astralyx builds: what is yours — models, data, files, functions — stays on the machines that are yours.

-   **Models, functions, runs**On your machines. A light box's question reaches your model through Astralyx, in memory only, over the connection your machine opened; the prompt and the answer are written nowhere but the box's outputs.
-   **What an execution keeps**Its event (at most 128 KiB), each box's state and its outputs — small by design: 16 KiB for a light box, 4 KiB for a run. Big things belong on a drive, with their path in the event.
-   **Files**On the execution's drive, on your machines — a folder of a drive of yours, if you name one.
-   **A trigger's address**Its secret is shown once. Its last calls are kept for 30 days — when, the answer's status, the execution started — never what a call carried.
-   **What leaves on purpose**A notify box's title and message go to your inbox, your phone and, if you linked it, Telegram: write in them what you would put in a notification.

## What we are building next.

None of this is available yet.

-   **For each item**A box that runs once per item of a list — each transaction of a statement, each machine of a pool.
-   **A table per workspace**History a workflow writes and reads back — transactions, health numbers — kept in your workspace.
-   **More triggers**Home Assistant and MQTT, e-mail arriving, files arriving on a drive, and events of the cluster itself. Until then, most of these can call a webhook.
-   **Camera recipes**Recipes for Frigate: an alert and its snapshot, described by a model that sees, and you told when it matters.
-   **More cluster boxes**Multi-machine jobs, notebooks, evaluations and benchmarks — with an agent doing the work and a supervisor checking it, in a loop.

## Questions we are asked.

**Is it like the automation tools I know?**

In shape, yes: something happens, boxes run, people are told. The difference is where the work is done: the models, functions, runs and agents are yours, on your machines, and a box can be hours of GPU work as easily as a one-second call. If what you need is mostly to connect many hosted apps to each other, with no models or machines of your own, a hosted automation tool is the better choice.

**Does a workflow need a GPU?**

No. Light boxes call what is already up: a small model served with [Eos](https://astralyx.cloud/eos) on CPUs answers Ask a model and Classify, and a function runs on any machine. GPUs are for the boxes that need them.

**Can my product call a workflow and get an answer?**

Yes: an HTTP trigger in sync mode is the workflow as an API. The call waits — 60 seconds by default, up to 90 — and is answered with the workflow's outputs as JSON. Past the wait, it is answered with the execution to look up later.

**What happens if a machine goes down mid-workflow?**

Nothing is lost. A run on that machine is placed on another, boxes already finished do not run again, and the execution goes on. Each box's attempts are on the execution's page.

**Can my AI assistant start a workflow?**

Yes: over MCP, Claude, ChatGPT, Cursor and other assistants list your workflows and start one as you, once you confirm it in the console ([how to connect](https://docs.astralyx.cloud/connect-ai-assistants/)). In the app and on Telegram, your own assistant does it from the chat — give it the Workflows area of its Astralyx tools — and tells you the result there when it ends.

**Can I write a workflow as code?**

Yes. The editor's YAML tab is the workflow itself; `astra iris workflows apply -f` applies a file, and Python builds one with `from astralyx.iris import Workflow`. All of them write the same object.

**How is it priced?**

Iris is in early access, as the other products are. Its runs and agents count like any other work on your machines; tell us what you want to automate and we will work out terms with you.

Early access

## Let your machines answer when something happens.

Start from a recipe, give it an address or a time, and watch every box of every execution.

[Request early access →](mailto:hello@astralyx.cloud?subject=Astraeus%20early%20access)[Build your first workflow](https://docs.astralyx.cloud/iris/get-started/first-workflow/)