Macro Routines turn a saved agent prompt into recurring or event-driven work. A routine needs a clear scope, a suitable trigger and a useful output. Scheduling an agent does not decide which records it should change or who should review the result.

Choose the trigger and execution identity

The Routines guide describes scheduled and activity triggers, with multiple triggers operating as alternatives: any matching trigger can run the routine. Routines use their creator’s permissions and are visible to that creator. The guide says Start enabled is on by default.

Before creating one, write the proposed task in a sentence. An illustrative example is “each weekday, draft a summary of unresolved onboarding tasks for the delivery lead.” Name the relevant project or channel and specify that the first version should draft a summary rather than make customer-facing commitments.

Understand the loop prevention boundary

The same documentation says agent- or bot-made changes do not fire activity triggers, while a GitHub pull-request-driven task change can. Do not design a chain that depends on an agent edit automatically triggering the next routine. Equally, do not assume every external change is excluded.

Design decisionQuestion to settle
ScheduleWhich timezone and working period apply?
ActivityWhich specific change should start the run?
ScopeWhich records may the creator access?
OutputA draft, a task or an approved record change?

Make the prompt identify its sources

Macro’s agent documentation describes using explicit references to provide context and agents inheriting user permissions. Point the routine at the actual source records and ask it to include references in its output. A general request to “update the CRM” leaves too much ambiguity about scope and evidence.

Separate a summary from an action. For example, a weekly overview can list three overdue tasks without changing their deadlines. A follow-up action should name the specific task and the permitted change. This makes review easier when the creator’s account has broad access.

Inspect the first run before adding more triggers

The routines guide documents Run Now and run history, including outcome, duration and the associated agent conversation. It also says Run Now can operate while a routine is disabled. Use that distinction when testing: disabling the schedule is not the same as removing every way to execute the routine.

Check a normal case, an empty source set and a record the creator cannot access. Inspect the actual output and changed records rather than treating a successful run status as sufficient evidence. Keep the initial trigger set small enough that staff can explain why each run happened.

Give maintenance an owner

Record who reviews failures, prompt changes and access changes when staff move roles. Monitor duplicate summaries and unreviewed actions alongside execution errors. A useful routine produces work that someone can understand and own, even after the original creator is no longer watching every run.

Defining the Scope of Each Routine Before You Build It

One of the most consequential decisions in deploying scheduled agents is not which trigger to choose but what the routine is actually permitted to touch. Scope is distinct from access. A creator's account may reach hundreds of records, yet a well-designed routine should be constrained to a deliberate subset. Without that constraint, a prompt that works correctly on a small project can produce unexpected output when the same creator later has broader access, or when the underlying data grows in ways the original author did not anticipate.

A practical way to define scope before building is to write three lists: records the routine should read, records it may change, and records it should explicitly ignore. This exercise frequently reveals ambiguity that a vague prompt would have passed silently to the agent. For instance, a routine intended to summarise open client requests may, without a list of what to ignore, include internal test records, archived projects or records belonging to a different team that the creator can technically read. Producing those lists forces a conversation between the person building the routine and whoever owns the underlying data.

Consider a fictional scenario to make this concrete. A delivery operations team creates a routine that should each morning produce a draft list of tasks without an assigned owner. The creator writes the prompt as "find tasks without an assignee and draft a message for the delivery lead." During a scope review, the team realises the creator's account can see tasks across four separate client channels, but the intended scope is one channel only. Without a channel reference in the prompt, the first run might return a mix. The resolution is to add a precise project or channel reference to the prompt text, not to rely on the creator's habitual working context. This kind of review is possible before any routine goes live and costs far less than investigating unexpected output after the fact.

Scope also has a temporal dimension. A scheduled routine running each weekday sees whatever state the records are in at execution time. If a record category changes meaning mid-project, the routine's output changes too, without any prompt edit. Building a short written description of what the routine should produce, and comparing that description to actual output periodically, gives the maintenance owner a stable reference point rather than relying on memory of the original intent.

Distinguishing the Identity of a Request from the Identity of the Customer

Scheduled agents raise a question that manual processes rarely surface: when the output reaches a staff member or a customer, whose request is it responding to? In a manual workflow, a human reads a specific inbound message and drafts a reply. In a routine, the agent runs on a schedule regardless of whether any individual asked for that particular output at that moment. This distinction matters operationally because it affects how staff should treat the output and how customers should be addressed.

If a routine produces a draft summary of customer onboarding status, that draft is a business-initiated document, not a response to a customer request. Staff reviewing it should apply the same editorial judgement they would to any internally generated briefing: verify that the facts are current, that no customer commitment is stated without authorisation, and that the tone is appropriate before any version reaches a client. The routine's output is a starting point for a human decision, not an autonomous customer communication.

The distinction becomes more nuanced when a routine is triggered by an activity such as a status change on a customer task. In that case, there is a specific change event, but the entity that caused the change may be a team member, an integration, or in some cases another automated process. Before treating the routine's output as a response to a customer action, staff should check the change history to confirm what actually occurred. This matters when the output includes language like "following your update," which would be misleading if the triggering change was made internally.

A useful evaluation question when reviewing a proposed routine is: if a customer or an auditor asked who requested this output, what would the answer be? If the answer is "the schedule," then the output should be framed internally as a business-generated document. If the answer is "a customer action triggered this," then staff should verify that the triggering action is accurately attributed before the output is acted upon or communicated externally.

Evaluating Trigger Combinations and Their Operational Consequences

Routines can combine scheduled and activity-based triggers, and understanding how those combinations behave is more operationally significant than it might appear. When multiple triggers are configured as alternatives, each one is an independent path to execution. A routine that runs on a schedule and also responds to a specific status change can therefore run more frequently than the schedule alone would suggest, and the additional runs may not be visible in a dashboard view that shows only the most recent execution.

A practical way to evaluate a trigger combination before deploying it is to map a week of realistic activity and count the expected runs manually. If a routine is scheduled daily and the activity trigger is a field that changes several times per day, the combination may produce more output than staff have capacity to review. Unreviewed output is not a neutral state; it represents decisions deferred, and in some operational contexts it creates a backlog that is harder to address than the original problem the routine was meant to solve.

The loop prevention boundary described in the product documentation, where agent-made changes do not fire activity triggers, is a structural safeguard but not a complete guarantee that chains will behave as intended. Consider a fictional scenario where one routine marks a task as reviewed and a second routine is triggered by any status change on tasks of that type. If the second routine's trigger predates the loop prevention rule or if the change is made through an external integration rather than directly by the agent, the expected boundary may not apply. Evaluating this requires inspecting what actually causes the activity trigger, not just assuming the boundary covers the intended case.

When assessing trigger combinations, useful questions include: under what realistic circumstances would both triggers fire on the same day, and would the combined output be coherent or contradictory? Who would notice if the activity trigger fired outside business hours, and is the output still appropriate in that context? Is there a way for staff to distinguish a scheduled run from an activity-triggered run in the output itself, so they can apply appropriate context when reviewing?

Designing Output for Human Review Rather Than Silent Action

The difference between a routine that drafts output and one that makes changes directly is significant enough to be a standing policy question, not just a technical setting. Drafting is generally lower risk because it preserves a review step, but a draft that is never reviewed provides no benefit and may create a false sense that the work is being done. Designing output for genuine human review requires more than producing a draft; it requires that the draft be structured so a reviewer can quickly assess its accuracy and make a decision.

A draft output that lists sources, states which records were considered, and flags any records it could not access is far more reviewable than one that presents conclusions without provenance. When the routine includes references in its output, a reviewer can spot-check specific records rather than having to re-derive the agent's reasoning from scratch. This is particularly important when the creator has broad access and the routine is therefore drawing from a large pool of records. A reviewer who does not share that access level needs the output itself to explain what was included and why.

Consider a fictional weekly routine intended to identify client projects that have not had a status update within a defined period. A well-designed output would list each project by name, show the last update event and its author, and note any projects where the routine could not retrieve update history. A poorly designed output would simply state "three projects need attention" without identifying them. The former allows a delivery lead to make an informed decision about follow-up. The latter requires additional investigation before any action can be taken, making the routine a net addition to workload rather than a reduction.

For routines that are eventually authorised to make direct changes rather than drafts, the same principle applies in reverse. Each change should be logged with enough detail that a reviewer looking at the record can determine when the change was made, what prompted it and what the previous state was. This is a design requirement for the prompt and the routine structure, not something that can be added retrospectively after a change has been made and questioned.

Handover Arrangements When Staff Move Roles

Routines run under the permissions of their creator, which means a change in that person's role, access or employment creates a risk that is easy to overlook during operational transitions. If a creator's permissions are reduced or removed, a routine may silently fail to access records it previously could, produce incomplete output, or in some configurations stop running entirely. If permissions are expanded for unrelated reasons, the routine's scope may grow in ways that were never intended.

A practical handover arrangement should identify, for each routine, the creator's current role and access level, the records the routine is expected to reach, and a named person who will review the routine's behaviour if the creator's situation changes. This is a record-keeping task, not a technical one, and it can be maintained in a shared document or project record alongside the routine's prompt text and intended output description.

Handover should also address the review function. Routines that were actively monitored by their creator may receive less scrutiny once that person has moved on. A successor who inherits responsibility for a set of routines without a briefing on each one's purpose is likely to treat continued successful execution as evidence that nothing needs attention. A short written description of what each routine should produce, what a normal output looks like and what a failure or anomalous output looks like gives a successor the context needed to exercise genuine oversight rather than passive monitoring.

When evaluating whether a routine has been properly handed over, observable evidence includes: a named current owner who can describe the routine's purpose without referring to the original creator, a record of at least one deliberate review of actual output against the intended description since the handover, and confirmation that any access changes to the creator's account have been assessed for their effect on the routine's scope. These are observable, auditable conditions rather than assumptions about system behaviour.

A Practical Acceptance Exercise for a New Routine

Before marking a routine as production-ready, running a structured acceptance exercise produces more reliable confidence than a single successful test run. The exercise should cover at least three cases: a normal case where the expected records exist and are accessible, an edge case where the source set is empty or minimal, and an exception case where at least one relevant record is outside the creator's access. Observing the output across these three cases reveals whether the routine handles variation gracefully or produces misleading output when conditions are not ideal.

For the normal case, compare the routine's output line by line against a manual review of the same records. Any discrepancy is worth investigating even if the overall output looks reasonable. For the empty source case, check whether the routine produces a clear indication that nothing matched rather than a blank or an error. For the access exception case, check whether the output notes the inaccessible record or silently omits it. Silent omission is more dangerous than an explicit note because a reviewer has no way to know the output is incomplete.

Document the expected output for the normal case before running the acceptance exercise, so the comparison is against a pre-stated expectation rather than a post-hoc judgement. This discipline is particularly useful when multiple people are involved in designing and reviewing the routine, because it surfaces disagreements about expected behaviour before they become operational problems.

Keep the acceptance record alongside the routine's prompt and scope documentation. When the routine is later modified, the acceptance record provides a baseline for comparing whether the change has affected output in expected or unexpected ways. A routine that has been through a documented acceptance exercise and has a named owner with current oversight is in a materially stronger operational position than one that has simply been running without incident, because the former reflects deliberate understanding and the latter may reflect undetected gaps.

Related guides

Comparing business systems? Explore the Sysevo platform or book a Sysevo demo against the same requirements. This is an independent Sysevo editorial guide based on the linked vendor documentation, reviewed 2 November 2026. Examples are illustrative; no hands-on vendor test or guaranteed result is claimed. Sysevo publishes this guide and sells its own software.

For current Sysevo subscriptions and usage options, compare plans and pricing.