Turn repeatable coding work into an automation.

Use an agent when the task needs reasoning and a repository command when it does not. Neroli keeps both types of repeatable work visible, inspectable, and connected to the resulting session.

Request access Read the docs

Automation availability depends on the provider, trigger, and runtime configured during the Neroli beta.

Why Neroli

Automate the task without hiding the work.

Recurring coding work should be easy to run again, but it still needs the right execution model, a visible result, and a path for human follow-up.

Agent automations for reasoning work

Save a defined coding task as an agent workflow and run it as an ordinary Neroli session with its conversation, tools, and result visible.

Workspace Commands for scripts

Keep deterministic repository setup, checks, services, and cleanup as project-owned shell commands instead of spending an agent turn on them.

Manual, scheduled, and session triggers

Start work on demand and use supported schedule or session-lifecycle triggers where the automation or command type allows it.

Local and cloud runtimes

Run local repository commands on the Mac and use supported cloud agent workflows when the work should continue remotely.

Runs you can inspect

See run state, duration, runtime, trigger, provider details, and change counts when those details are available for the workflow.

Follow up like any other session

An agent automation run remains a normal session, so you can read the transcript, inspect changes, and provide a manual follow-up.

The workflow

Choose the runner, define the work, inspect the result.

Neroli separates model-driven work from deterministic scripts so each workflow uses the simplest tool that fits.

  1. 1

    Choose the right automation type

    Use an agent automation when the task needs model reasoning. Use a Workspace Command when a repository script can do the work directly.

  2. 2

    Define the repeatable input

    Write the agent prompt once or store the project command in the repository so the workflow is inspectable and can evolve with the codebase.

  3. 3

    Select the supported trigger and runtime

    Run it manually or configure an available schedule or session event, then keep the workflow local or use cloud where that automation supports it.

  4. 4

    Inspect the run and its changes

    Open the resulting session, read what happened, review command state and code changes, and continue manually when judgment is still required.

Agent work

Prompt once, then keep the result inspectable.

Agent automations package recurring reasoning work without hiding it behind a background job. The run appears in the same session model as hands-on agent work.

  • Saved task instructions
  • Provider and runtime chosen by the workflow
  • Transcript, changes, and follow-up in a session

Repository work

Use commands when a command is enough.

Workspace Commands keep predictable work fast and reviewable. They belong to the repository and can prepare, run, check, or stop the project's own tools.

  • Project-owned shell commands
  • Manual and supported lifecycle execution
  • No model turn required for deterministic scripts

Operations

One place to see what ran.

The automation overview and run history make recurring work visible instead of leaving schedules, terminal output, and agent sessions disconnected.

  • Current state and recent history
  • Trigger, runtime, provider, and duration where available
  • Changes associated with the resulting session

Questions

What developers ask.

What is a coding agent automation?

In Neroli, an agent automation is a saved coding workflow that runs through a supported provider as an ordinary session. Its conversation, state, tools, and changes remain available for inspection and follow-up.

What is the difference between an agent automation and a Workspace Command?

Agent automations use a coding agent for work that needs reasoning. Workspace Commands run repository-owned shell scripts for deterministic setup, services, checks, builds, or cleanup without spending an agent turn.

Can Neroli schedule coding agent work?

Neroli supports scheduled automation runs. Available triggers and runtimes depend on the automation type and configured provider, so the product documentation is the source of truth for current beta support.

Can automations run locally and in Neroli Cloud?

Workspace Commands are local repository workflows. Supported agent automations can use a cloud runtime, and their resulting sessions remain visible from the Mac workspace.

Can I intervene after an automation runs?

Yes. Agent automation runs use the normal session lifecycle, so you can open the transcript and changes, provide a manual follow-up, or continue the work from the session.

Field guide

Turn the Xcode task lifecycle into repository-owned commands.

Use a practical setup prompt and pull-request checklist for repeatable setup, builds, verification, and cleanup on a Mac.

Read the Xcode software factory guide

Keep exploring

Isolated workspaces Prepare the branch, worktree, ports, and services around a task.
Coding agent verification Attach repository checks and interactive proof to the result.
Neroli Cloud Run supported agent work in an isolated cloud environment.

Neroli beta

One Mac workspace for all your coding agents.

Tell us how you work today and which provider you want to run first.

Request access