Duties
Give a Praxis agent standing work it runs unattended, whether on a schedule, watching a Slack channel, or fired by a webhook, so it monitors your systems and reports back without changing them.
A duty is a standing job you hand a Praxis agent so it runs on its own, with no one in the session. You define what it should do once, as a plain-language objective, and the agent carries that out every time the duty runs, reporting what it finds. It is the difference between asking Praxis a question now and giving it a job to keep doing.
Every duty is run by an agent: Praxis itself by default, or a custom agent you have built.
Three kinds of duty
A duty is defined by what sets it off. The three kinds share the same idea of a standing objective but run on different triggers.
| Kind | What triggers it | Use it for |
|---|---|---|
| Schedule | A clock (a cron cadence) | Recurring checks and audits that report back on a fixed schedule |
| Watch | A Slack message | An agent that answers in a channel, or watches one and chimes in |
| Webhook | An external HTTP call | Letting another system start an agent run on demand |
You create any of them from the Duties page: choose Add a duty, then pick the trigger. You can also start from an existing agent and choose Put on duty.
Set up a schedule duty
A schedule duty is the most common kind. Setup begins with a short form and finishes as a conversation with Praxis, so you never have to know every field up front.
Describe the duty in your own words in the objective field, then pick how often it should run (a preset such as every hour or every weekday, or your own cron expression) and the timezone to read it in. If you already know them, you can pre-fill a target, a Slack channel, or a Git repository; whatever you leave blank, Praxis asks about next.
Choosing Continue with Praxis opens a chat where Praxis proposes a name, confirms the cadence, asks what to point the duty at, and only saves the duty once you approve it in the conversation. Nothing is stored until you confirm.
A duty's target is what it inspects on each run: a Facets environment or a Kubernetes cluster your organization has connected. You can narrow the target to a single deployment so the agent focuses there first.
Watch a Slack channel
A watch duty listens to a Slack channel instead of a clock. Pick the agent, the connected Slack workspace, and the channel, then choose how it responds: @mentions only, where it replies when tagged, or All messages, where it reads everything in the channel and chimes in on its own. You can optionally link a Facets environment so the agent has context for what it is asked.
Connected channels are managed in the same place: change the response mode, pause a channel, or disconnect it.
Fire a duty from a webhook
A webhook duty runs when an outside system calls it. Assign an agent, name the duty, write its objective, and optionally set a target. Saving mints a public URL. Any caller that sends a POST to that URL starts one agent run in the background and gets back a run id immediately. An optional JSON body, {"extra_instructions": "..."}, adds a one-off note for that single run.
The UUID in the webhook URL is the only credential that protects it, so treat the URL like a password. Anyone who has it can fire the duty. If it leaks, open the duty and choose Rotate URL: the old URL stops working at once.
Save a chat as a duty
If you have already worked something out with Praxis in a chat, the Save as Duty action turns that session into a schedule duty. You give it a name, a cadence, and a timezone; it carries over the objective and any deliverables the chat produced, so the duty starts from where the conversation left off.
How a scheduled run works
Each time a schedule duty runs, whether its cron fired it or you triggered it yourself, the agent works through the same arc:
- Loads its context. It reads the objective, short digests of recent runs, any findings still open from before, and its learnings, the operating notes it wrote for itself on earlier runs so it does not rediscover the same context every time.
- Investigates. It reads logs, events, cluster state, and release history to work through the objective, inspecting only.
- Records findings. Each distinct issue is tracked over time, so the same problem returning on a later run counts as a recurrence rather than a fresh finding. A finding stays open until it is resolved, and reopens if it recurs.
- Reports. It saves the full run as a report you can open, posts a summary to Slack if a channel is connected, and opens a GitHub issue or pull request when a repository is attached and a finding warrants one.
You can trigger a run yourself between scheduled ones, and attach a note that applies to that single run.
Watch and webhook duties run the same agent against the same kind of objective, but skip the findings-and-learnings loop: they carry out the objective when triggered, and webhook runs are recorded with their status, duration, and cost.
What a duty can and cannot do
A duty investigates and advises. Against your infrastructure it stays read-only: it can list, describe, and read logs freely, but commands that would change something, such as apply, create, delete, scale, restart, or roll back, are blocked at the tool layer rather than merely discouraged.
Its only outward actions are proposals a person reviews:
- a summary posted to a Slack channel, and
- a GitHub issue or pull request, when a repository is attached. The duty opens the pull request; it never merges it.
Because a duty runs unattended, it is built to observe and propose, not to act on its own. A person always decides what to do with what it finds. For how Praxis runs commands server-side under your own permissions, see How Praxis works.
Manage your duties
The Duties page lists every schedule, watch, and webhook duty in one grid. Each tile shows the kind, the agent that runs it, and its state: a schedule shows its cadence and a count of open findings, a watch shows its channel and response mode, and a webhook shows when it last fired. Search across them, or filter by kind (schedule, watch, or webhook) or by state (errored or paused). The Activity view collects recent runs across all your duties in one place.
Open a schedule duty to see its run history, with each run's status, duration, cost, and a link to its report and transcript; its findings, marked open or resolved with a recurrence count, where you can mark an open finding resolved yourself; and its learnings, which you can delete individually when a note is wrong. Open a webhook duty to see its URL, its run history, and its controls.
A duty is always in one of three states:
| State | Meaning | How it gets there |
|---|---|---|
| Active | Running on its trigger | The normal state once it is set up |
| Paused | Stopped until you resume it | You pause it yourself |
| Error | Auto-paused after repeated failures | Three runs fail in a row |
The Error state is a safety catch: a schedule duty that fails three runs in a row pauses itself, so a broken or misconfigured duty does not keep firing. Fix the cause, then resume it. Watch and webhook duties have no Error state; you pause or activate them yourself.
Pausing keeps a duty and everything it has recorded intact. To stop one for a while, pause it rather than delete it, since deleting a duty is permanent.
Related
- Build your own agent - Build a custom agent and put it on duty
- How Praxis works - Server-side execution, your permissions, and the read-only default
- Repositories - Connect a Git repository so a duty can open issues and pull requests
- Connect tools - Connect Slack and the integrations a duty runs against
Alert Doctor
Praxis Alert Doctor continuously reviews and refines a project's shared Prometheus alerting rules, proposing changes and applying them safely and reversibly when enabled.
Cloud operations and cost
Explore your AWS, GCP, and Azure resources and surface wasted spend through read-only queries, without leaving a Praxis conversation.