> For the complete documentation index, see [llms.txt](https://docs.autommate.com/userguide/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.autommate.com/userguide/service-automation/deploy-a-service-to-msp-tenants.md).

# Deploy a service to MSP tenants

Select tenant targets, configure phase bindings, test the draft and make the service live.

Deploy a reusable service to selected MSP tenants, configure each target and test its draft before making it live. This guide starts with a published service and an existing test tenant.

Use the tenant workflow below to configure an MSP service. The request-intake example uses fictional data. Check each operator's access before handover using the account checks at the end of this guide.

#### 1. Prepare the service and tenant

Prepare the published service, released Work Items, intended tenant, required input values and a suitable Mate Agent. An AI Agent that interprets requests and a Mate Agent that executes automation have different roles.

Use credentials and application connections approved for the selected tenant. Confirm the tenant name before entering its values.

Deployment owner assignment is planned for a later version. Record the operational contact separately until the field is available.

#### 2. Select the tenants and Work Items

In MSP Hub, open the ready service and select Deploy. Select the tenants that should receive it. Then select the Work Items you want included for those tenants.

Check the service version and target list before continuing. Start with one test tenant when configuring the service for the first time.

Enterprise uses a deployment route without tenant selection. Follow the edition-specific guide for that environment. See [Create an Enterprise service deployment draft](https://docs.autommate.com/userguide/service-automation/create-an-enterprise-service-deployment-draft.md).

#### 3. Configure the phases

Continue through Engage, Govern, Execute and Prove. Configure each step's required credentials and fields for the selected tenant. Review the Mate Agent, input bindings and phase settings before saving.

Variables marked Use as Work Item Input are requested during deployment. To provide an output to following Work Items, assign the producing variable to the Stop body, release the Work Item and pin it in the service. Select the prior output in the consuming input binding and inspect the resolved value in a tenant test.

Review which Work Items are included for the target. Keep required Execute work and any Prove check needed for the promised outcome.

A tenant selected by an MSP administrator identifies the deployment target. Verify individual operator access separately before handing over the service.

#### 4. Create and test the tenant draft

Deploy saves the configuration as a draft for the tenant. In Deployments, confirm which service and version belong to that tenant, then run a controlled request:

* Reopen the tenant draft and confirm its service version, Mate Agent and input values.
* Invoke the generated service entry with POST, the configured authentication and the actual input body. Retain \&dev in the URL to target the development draft.
* Locate the matching Service Case by service and request time. Inspect its tenant, package, version, environment and phase history.
* Compare the Work Item action data with the expected result. If Prove is part of the service promise, inspect its actual check as well.

After the draft passes its checks, use the live transition for that deployment. The dev marker is removed and the API entry targets live. Keep the development and live entries distinct in caller configuration.

#### Review the configuration before going live

| Check            | Evidence to record                                                                  |
| ---------------- | ----------------------------------------------------------------------------------- |
| Target selection | Where the tenant is selected; its actual identifier and display name.               |
| Version          | Published blueprint and released Work Item versions used by the package.            |
| Scope            | Selected Engage, Govern, Execute and Prove work, including parallel groups.         |
| Execution        | Mate Agent selection and any tenant-specific eligibility or default.                |
| Binding          | Input type and source; credential, shared-value and prior-output references.        |
| Ownership        | Not available in this version; do not infer owner-based access or execution rights. |
| State            | Saved draft versus live package; the exact entry intended to invoke each.           |

When trying two demo tenants, use different harmless input values for each. Inspect the resolved Work Item input in each Case so the selected target and its data can be checked together.

Review the scope of a Foundation Global Variable before using it for tenant-specific data. For credentials and sensitive values, check the resulting log and response views before exposing the service to operators.

## A small tenant binding exercise

For a small second exercise, use the same published service with Demo North and Demo South. Make the request identifier an explicit Work Item input instead of a hard-coded value, then use these fictional test values:

| Test target | Sample request identifier | Result to check                                               |
| ----------- | ------------------------- | ------------------------------------------------------------- |
| Demo North  | `REQ-DEMO-NORTH-001`      | North's Case and Work Item input contain the North identifier |
| Demo South  | `REQ-DEMO-SOUTH-001`      | South's Case and Work Item input contain the South identifier |

1. Open the ready service in MSP Hub and select Deploy. Select Demo North and Demo South as the target tenants.
2. Select the Work Items to include for those tenants, then configure Engage, Govern, Execute and Prove. Map each sample request identifier through the actual input contract.
3. Review the intended tenant, version, Mate Agent, credentials and fields. Create the drafts, then check their service-to-tenant associations in Deployments.
4. Invoke each tenant draft with its development entry and the corresponding sample data. Locate each matching Service Case.
5. Compare the Case context and resolved input: North should contain REQ-DEMO-NORTH-001; South should contain REQ-DEMO-SOUTH-001. Investigate any mismatch before going live.

This exercise checks deployment targeting and input data. Repeat the required tasks with separate role accounts to check operator access; changing tenant context while signed in as an administrator is a different test.

#### Check access before operator handover

Agree the permitted actions with your administrator, then test each intended account. The table lists checks to perform, not permissions already proved by this guide.

| Account                           | Validation focus                                                                   |
| --------------------------------- | ---------------------------------------------------------------------------------- |
| MSP Admin                         | Intended tenant administration, service design, deployment and operational views.  |
| Technician assigned to one tenant | Permitted actions in that tenant and denied access to the other known demo tenant. |
| Tenant administrator              | Tenant-scoped administration, service visibility and permitted operations.         |
| Standard tenant user              | Only the views and actions explicitly allowed for that user.                       |

Check read, change, release and execution permissions separately with the approved demo accounts. Confirm denied access to a known out-of-scope demo resource as well as permitted access to the assigned tenant. Keep these tests in the approved demo environment.

#### Inspect the resulting Case

Open the Case that matches the request time and tenant. Confirm its pinned service and Work Item versions, Status, Result, Context and action history. Compare the returned or assigned data with the service's success criterion.

If the trigger returns Flow triggered, continue to the Case rather than stopping at the acknowledgement. The Case shows which deployment ran and how its phases finished.

For an independently verified business outcome, Prove must check the actual result of Execute. Assigning a fixed success string is suitable for a wiring demonstration, but it does not verify an external business result.

#### Keep a short handover record

Record the tenant, service and Work Item versions, package/environment, operational contact, expected result and matching Case identifier. Note any failed or untested access checks. Recheck the affected target after changing versions, credentials or bindings.

Review inherited settings and deliberate deployment overrides when configuring the phase rules. See [Configure phase behavior](https://docs.autommate.com/userguide/service-automation/configure-phase-behavior.md).

### Test scope and package versions

The tenant procedure must be tested in an MSP-enabled environment. The earlier Presales runtime exercises use Enterprise. The output-binding walkthrough below verifies configuration and scalar-value transfer in one MSP tenant; neither exercise validates cross-tenant isolation or role-based access. Use approved MSP test tenants and role accounts for those checks.

Draft and live are separate packages. Selecting a newer service version does not replace an existing draft. To create a draft from a newer published service version, either remove the existing draft only when it is disposable and deletion is approved, or promote that existing draft only after it has passed the intended go-live checks. Then create a new draft from the required service version and recheck its package, bindings and pinned Work Items. Do not promote a draft merely to bypass an update question.

When one input contains several selected variables, the result is a plain string. Select scalar values or nested keys. Combining a whole Object and a whole Data Table in one field is not a supported merge. For example: ##connected\_user\[user\_name]## has asked for an approval. approval id is ##approval\_id## and the external request id is ##ServiceNow\[request]\[id]##. Check the resolved input in a test run before using it to send an approval.

### Worked example: pass Govern output into Execute

Build two small Work Items to pass a request identifier through a tenant draft. Govern returns a fixed JSON object. Execute receives its request\_id and displays the value in an action log. The fixed Yes result is only a test value, not a real approval decision; this service has no Prove check.

The controlled development run on 14 October 2026 used Govern v1.0.1 and Execute v1.0.2. Execute's actual Display Message input contained Received request marker: DOCS-20261014, matching the producer's value. The tenant draft was not made live.

#### 1. Return actual data from Govern

1. Create a Govern Work Item with Start → Display Message → Stop. Use a harmless fixed message for the test step.
2. Open Stop. Set Result to Yes, Response Status Code to 200 and Body Response Type to application/json.
3. Enter {"request\_id":"DOCS-20261014","approved":true} in the actual response body below Body Response Type.
4. Enter the same JSON in Example response. This sample describes the fields available in the deployment picker; it does not supply their runtime values.
5. Save and release the Work Item. Reopen the Active release and inspect Stop again: the actual body must contain the JSON and the response status must be 200. The verified example uses Govern v1.0.1; pin the release you actually verified.

Keep the two fields distinct: the Stop body produces runtime data; Example response describes its shape. Filling only Example response can expose request\_id in the picker while leaving the producer's actual response empty.

<figure><img src="https://3857940684-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FJcSHU5jP5GABQrGmWvW2%2Fuploads%2FiXvMdYcnK5eIYac5Pd7i%2Fgovern-v101-stop-verified.jpg?alt=media" alt="Inspect the Active Govern release: the actual Stop body and Example response both contain the sample JSON; the response status is 200."><figcaption><p>Inspect the Active Govern release: the actual Stop body and Example response both contain the sample JSON; the response status is 200.</p></figcaption></figure>

#### 2. Receive and display the value in Execute

1. Create an Execute Work Item. Add a String variable named request\_marker with default value UNBOUND and enable Use as Work Item Input.
2. Build Start → Display Message → Stop. Set the message to Received request marker: ##request\_marker## so the resolved value can be inspected in its action log.
3. Set Stop to Result Yes, Response Status Code 200 and Body Response Type application/json. Enter {"request\_id":"##request\_marker##"} in the actual body and {"request\_id":"DOCS-20261014"} in Example response.
4. Save, release and reopen the Active version to check the input definition and actual Stop fields. The verified example uses Execute v1.0.2.
5. Create a new example service with Webhook for Engage, one Govern item and one Execute item. Pin the verified releases—Govern v1.0.1 and Execute v1.0.2 in this example—and leave Prove empty for this wiring test. Publish the service version.

<figure><img src="https://3857940684-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FJcSHU5jP5GABQrGmWvW2%2Fuploads%2F5LiAM2p4fPU4OwJB0tpb%2Fexecute-v102-stop.jpg?alt=media" alt="Inspect the Active Execute release: Stop returns the bound request_marker in a JSON body. The Display Message action provides a separate place to inspect the resolved input."><figcaption><p>Inspect the Active Execute release: Stop returns the bound request_marker in a JSON body. The Display Message action provides a separate place to inspect the resolved input.</p></figcaption></figure>

#### 3. Bind the previous output in a tenant draft

1. Open the published service and create a New deployment. Select an approved test tenant and its Mate Agent. The verified example used Default Tenant and the default agent.
2. In Scope, include both example Work Items. Continue through the phase steps to Execute and select the Execute Work Item.
3. At the Request marker input, select + → Work item output → the Govern Work Item → request\_id (string). Check that the field shows 1/1 bound.
4. Use the picker-generated token. Its shape is ##work\_item\_result\_\<generated-id>\[request\_id]##; do not copy an identifier from another deployment.
5. Continue to Review and save the draft. Reopen it and check the tenant, service version, pinned Work Item versions, agent, scope and binding. The verified example created Development draft Package 1 for the service Docs — Verified Marker Wiring. It was not promoted to Live.

#### 4. Run once and inspect the actual input

1. After checking the configured authentication, call the generated development entry with POST and JSON body {}. Retain the development marker in the generated URL. GET does not start this example.
2. Find the Service Case for your request time and service. Confirm its tenant, package, development environment and pinned versions before inspecting the result.
3. Open Log History, then View All Logs. Open the Execute Work Item and its Display Message action. On Input, inspect the resolved message.
4. Compare the actual value with the fixed Govern value. For this example it must be Received request marker: DOCS-20261014. A completed Case alone is not this check: null, an empty value or UNBOUND means the expected marker has not been demonstrated.

<figure><img src="https://3857940684-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FJcSHU5jP5GABQrGmWvW2%2Fuploads%2Ffe8xrMOu7wtwIEBjoebM%2Fmarker-actual-input.jpg?alt=media" alt="Read the Execute action&#x27;s actual Input: Received request marker: DOCS-20261014 confirms that this scalar value reached the consuming Work Item."><figcaption><p>Read the Execute action's actual Input: Received request marker: DOCS-20261014 confirms that this scalar value reached the consuming Work Item.</p></figcaption></figure>

Observed result: the corrected development run finished Done / Success and the Execute Display Message input contained the expected marker. This verifies the scalar binding in this synthetic configuration. The test inspected the message input; the Stop JSON shown above is its configured response, not a separately verified external result.

<figure><img src="https://3857940684-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FJcSHU5jP5GABQrGmWvW2%2Fuploads%2FdSEgl9tEq9dqU8YYlbtc%2Fmarker-case-journey.jpg?alt=media" alt="Inspect the same Case journey: Engage, Govern and Execute are Done; Prove is Skipped. Pair this view with the actual action input rather than relying on status alone."><figcaption><p>Inspect the same Case journey: Engage, Govern and Execute are Done; Prove is Skipped. Pair this view with the actual action input rather than relying on status alone.</p></figcaption></figure>

This exercise does not verify an external business outcome, a Prove check, live operation, cross-tenant isolation or operator permissions. Add and test those checks for the real service before handover.

#### If the marker is missing

First reopen the producing Work Item's pinned Active release and check its actual Stop body, not only Example response. Then check the consuming input definition, picker selection, saved package and versions that ran. A successful technical execution can still contain a null or incorrect value. Share a redacted Case and action log with <support@autommate.com> if the expected value is still missing. Keep authentication values and generated endpoint URLs out of shared screenshots, and check the previous execution before submitting again.
