Operations

Connect a worker when Mobius needs work to run in your own process. Use this for private network calls, local code, or a local model stack.

The worker opens an outbound connection to Mobius. It claims compatible action work, returns results, and heartbeats until it exits.

What you'll build

• An API key for a machine identity.
• A local stock worker on the default queue.
• A one-step action loop that calls the stock worker's print action.

Prerequisites

• The mobius CLI installed.
• A project handle. The examples use platform.
• Permission to create API keys and operate workers.

1. Create a worker key

Create a key from Govern > Machine identities or follow Create an API key. Export it in the shell that will run the worker:

export MOBIUS_API_KEY="mbx_..."
export MOBIUS_PROJECT="platform"

Use a worker-scoped machine identity for production. A personal login works for testing, but it is harder to rotate and audit.

2. Start the stock worker

Run the worker on the default queue:

mobius worker --queues default --concurrency 5

The stock worker registers small built-in actions such as print, json, time, random, and fail. Leave the process running while you start a run.

3. Create a worker-backed loop

Create a loop with one action step:

schema_version: "1"
name: worker-smoke-test
description: Send one print action to a connected worker.
concurrency: allow
triggers:
  - key: manual
    kind: manual
    enabled: true
steps:
  - id: print
    name: Print message
    kind: action
    config:
      action_name: print
      parameters:
        message: "Hello from Acme platform."

Start the loop manually from the app or the runs API.

4. Check the run

The run should suspend while the worker owns the action, then complete:

run.started
step.started     step=print kind=action
action.called    action_name=print
action.completed action_name=print
step.completed   step=print
run.completed

If the run stays suspended, check the worker process first. It should be online, heartbeating, and connected to the same project and queue as the action step.

Operating notes

• Use --concurrency for one process with several in-flight actions.
• Use --workers only when you need several independently visible worker sessions inside one CLI process.
• Split queues when slow actions should not block fast ones.
• Keep API keys narrow. The worker preset should be enough for claiming and completing worker-owned action work.

Next

• Understand worker sessions in workers.
• See worker-owned records in worker loops.
• Attribute machine access through API keys.