- Subscribe to RSS Feed
- Mark as New
- Mark as Read
- Bookmark
- Subscribe
- Printer Friendly Page
- Report Inappropriate Content
Two plugins, two plain-language prompts. One of them I had already built by hand — which makes it a fair measure of what ToolSmith takes off your plate, and of how much it knows about the system on the other side.
A few months ago, I wrote a mini-series about exploring Moveworks’ capabilities. The focus was on creating new plugins to see how easily we could extend Moveworks to manage Agile Stories in ServiceNow.
If you missed it, here is the full list of articles in the series:
Back then, all the building was manual work, no AI involved. Since then, ToolSmith has entered the scene.
ToolSmith is described as an assistant for building, changing, and debugging plugins from a plain-language description.
Because I accidentally deleted the plugin from Part 1 that made stories available in Moveworks, I figured this would be the perfect opportunity to test ToolSmith and compare it to the effort it took to build everything by hand.
The First Plugin
I didn’t really know what to expect from ToolSmith, so I decided to start with a very simple prompt. I expected the AI to ask for additional context if it was missing something, but I was genuinely surprised by the result.
Create a plugin which lets the user see the Agile Stories which are assigned to him on the ServiceNow Instance.
One sentence of plain language. ToolSmith starts by looking at what is already there.
As you can see in the screenshot and the full logs (at the end of this section), ToolSmith immediately checked the existing objects and noticed there was already a plugin for story creation and one for receiving assignment notifications.
I also quickly noticed that ToolSmith used a much simpler implementation method than I did. When I originally built this capability by hand, I used a Resolver Strategy that made a separate API call to the ServiceNow instance to fetch the user’s sys_id based on their email address stored in Moveworks. I then used that sys_id to query their assigned stories.
ToolSmith completely avoided this separate lookup and simply used dot-walking in the query: assigned_to.email. It also correctly recognized and reused my existing ServiceNow connector.
Within seconds (it was incredibly fast), ToolSmith presented a plan that I only needed to approve.
Three entities in Phase 1, verification in Phase 2 — and one button.
A few seconds after approval, ToolSmith built everything required. A quick test showed it was working perfectly.
The finished plugin in Otto: “my” resolves to the signed-in user, and the assigned stories come back with state, priority and last update.
Research scope:
- ServiceNow Agile Story lookup for the signed-in end-user.
- End-user identity mapping, plugin flow, and verification requirements.
- Existing ServiceNow entities that can be reused.
Initial design decision:
- I’ll use a read-only ServiceNow action and filter stories by the end-user’s mapped ServiceNow identity.
Key discoveries:
- ServiceNow Agile Stories are exposed through the Table API, so the workflow can query the story table with an encoded assignment filter.
- An existing story-creation action and conversational process exist. I’ll inspect them to reuse the ServiceNow connection and established field conventions.
- An existing “Notify about assigned story” plugin may already cover part of the requested behavior.
Design decision:
- I’ll avoid a separate ServiceNow identity lookup if the story query can dot-walk assigned_to.email using the signed-in end-user’s email.
Key discoveries:
- The existing ServiceNow action uses connector snow and table rm_story. I’ll reuse both.
- The Table API returns records in a result array and supports encoded queries, field selection, display values, limits, and sorting.
- The requested plugin is distinct from the existing notification plugin. It will be a conversational, on-demand lookup.
Remaining research:
- Confirm the available end-user identity context.
- Inspect existing assigned-story workflows for reusable formatting and identity mapping.
- Confirm the exact entity creation and verification inputs.
Key discoveries:
- The existing assigned-story automation only handles webhook notifications. It does not support on-demand lookup.
- The new conversational process can surface the HTTP action result directly, so no custom script is needed.
- The plugin will be restricted to Martin during initial validation, following the platform default for new conversational plugins.
Identity design:
- I’m confirming whether the process can read the current end-user directly. If not, I’ll use a required email slot with automatic inference from conversation context rather than asking for another person.
Key discoveries:
- No standalone connector entity is visible, but the existing production HTTP action resolves connector snow. I’ll reuse that established connector reference instead of creating a duplicate.
- A User slot is the correct identity mechanism. The default resolver can resolve “me/my” to the invoking end-user and provides the email used by ServiceNow.
- No custom DSL is required for the core flow. The API filter and response mapping can remain declarative.
Implementation shape:
- Read-only GET action on /api/now/table/rm_story.
- Conversational process with an assignee User slot and direct result surfacing.
- New plugin limited to Martin for verification.
Key discoveries:
- Existing GET actions confirm query parameters reference inputs with {{input_name}}.
- The ServiceNow query can filter assigned_to.email={{assignee_email}}.
- I’ll return a focused set of fields: story number, short description, state, priority, sprint, assignment, and record ID. Results will be ordered by most recently updated and limited to 20.
Verification design:
- I’ll execute the new read action with Martin’s email and require a valid ServiceNow result array.
- I’ll then provide a conversation test for the “show my Agile stories” intent.
Remaining research:
- Confirm the resolved User object’s email field.
- Confirm the verification tool inputs.
- Then I’ll create and submit the complete implementation plan.
Final design decisions:
- I’ll use a User slot named assignee. The process will resolve “me/my” to the invoking end-user.
- I’ll map the resolved end-user email into the ServiceNow filter.
- I’ll keep the result untransformed so the assistant can display the returned story fields without losing data.
- The initial plugin allowlist will contain only martin.rudack@agineo.de.
Verification rule:
- I’ll validate that ServiceNow returns a non-empty result list for Martin. This confirms authentication, filtering, table access, and real assigned-story data.
- I’m validating the MWDSL assertion syntax before adding it to the plan.
Assertion decision:
- I’ll use the documented implicit truthiness pattern result.result.
- I’ll test both non-empty and empty responses so the verification fails when no assigned story data is returned.
Plan structure:
- I’ll create the read action, conversational process, and plugin in dependency order.
- I’ll verify the live ServiceNow lookup, then send the developer a focused conversation test.
- The plan includes an external read action. It will run against ServiceNow once the plan is approved.
Plan complete:
- The plan creates three new entities and verifies each through dependency-aware execution.
- The ServiceNow verification is read-only and runs live after approval.
- I’m checking the final plan structure before submission.
Ready for approval:
- The plugin will show the invoking end-user’s assigned ServiceNow Agile Stories.
- It reuses the existing ServiceNow connection and applies standard log redaction.
- The plan includes an external action that runs against ServiceNow once approved.
I’ve finished executing the plan.
Here’s what changed
Create an on-demand plugin that resolves “my” to the invoking end-user, retrieves their assigned ServiceNow Agile Stories, and displays the latest story details. The plan includes external actions that run against ServiceNow once approved, followed by live and conversational verification.
02
The Second Plugin
Since the first plugin was much easier and faster than expected, I wanted to see how ToolSmith would handle the use case of notifying a user when a task is assigned to them.
I was especially curious to see if ToolSmith would tell me what I needed to configure inside ServiceNow to make it work, or if I would have to figure that out myself or consult Build Agent.
Because the simple prompt worked so well in the first example, I stuck with that strategy and provided a very basic request:
I need my Agents to be notified once a new Incident is assigned to them in ServiceNow. They should see a link directly to the incident.
The second prompt, and the moment ToolSmith decides this has to be event-driven.
It correctly detected that this required an event-driven pattern and that a similar setup already existed in my instance. It inspected my existing listener and built a plan to replicate that approach.
Listener, action, plugin — and the ServiceNow configuration as a step of its own.
The best part? The plan also included the exact configuration steps I needed to take on the ServiceNow side to make this work. After approving the plan, ToolSmith started creating everything automatically. I only had to step in to configure the credentials.
Here is the ServiceNow configuration ToolSmith recommended:
The ServiceNow side, spelled out field by field.
And the Business Rule script, ready to paste.
After setting up the Business Rule and the REST Message in ServiceNow exactly as instructed, it was time for a test.
It works — but the link is just text.
It worked! However, I wanted the link to be clickable, and I wanted it to route the user directly to the Service Operations Workspace (SOW).
The great thing is that if you need changes, you can just go back to the chat and tell ToolSmith what to adjust.
Changes go back into the same chat, in the same plain language.
A few seconds later, all the changes on the Moveworks side were completed. I only had to change one line in the Business Rule, and it worked exactly as expected.
One clickable link, straight into the incident in the Service Operations Workspace.
Researching: Tool Studio event notifications, webhook listeners, and ServiceNow incident fields and links. I’ll also check existing entities for reuse.
Key discoveries:
- The correct pattern is event-driven: ServiceNow sends an assignment event to a Tool Studio listener.
- An existing listener named Story_assigned may provide a reusable notification pattern.
- No ServiceNow connector is needed if the webhook includes the incident number, assignee identity, and sys_id; the incident link can be constructed from the ServiceNow instance URL.
- I need to inspect the existing listener and confirm the listener-to-notification configuration before designing the plan.
Design decision:
- I’ll mirror the proven Story_assigned architecture with new incident-specific entities rather than modify the existing story notification.
- ServiceNow will send the assignee email plus incident data. The plugin will map the email to the recipient and display the incident number, summary, and direct record link.
- I need the ServiceNow instance URL because it is required to build the direct incident link.
Required detail: I need the ServiceNow instance URL to construct links such as https://<instance>/nav_to.do?uri=incident.do?sys_id=<sys_id>.
Updated design:
- ServiceNow will trigger only when assigned_to changes to a populated value.
- The webhook payload will contain the assignee email, incident number, short description, and sys_id.
- The notification will include a direct link to the incident in xxxxxxx.service-now.com.
- I’ll create separate incident entities and leave the existing story notification unchanged.
Verification approach: I’ll send one sample incident notification to martin.rudack@agineo.de. This is a non-read test because it creates a real Moveworks notification. It will not modify ServiceNow.
I’m confirming the supported notification-link format before finalizing the plan.
Final configuration contract:
- Listener payload: email and data.
- data contains number, short_description, sys_id, link, and a complete message.
- The message includes the full incident URL, so it is visible and clickable without another conversation step.
- The assignment recipient is resolved from the ServiceNow assignee email.
Plan scope: I’ll create a secured incident webhook listener, a notification action, and a system-triggered plugin. I’ll then provide the exact ServiceNow Business Rule setup and verify the notification path with a real test notification to you.
Plan ready: I’ll build the event-driven incident notification flow, provide the exact ServiceNow configuration, send one real Moveworks test notification to you, and provide end-to-end validation steps.
Ready for your approval.
Failure: The implementation completed. The verification action failed during notification callback execution.
I’ll inspect the latest execution logs and current action definition to identify whether recipient resolution or notification delivery failed. I’ll then replace only the failed verification step.
Current evidence: The compound action definition matches the proven existing story-notification pattern. No execution log was returned with the email filter, so I’ll retry using only the verification work-item scope and inspect the created plugin.
Probable cause: The failure occurred in the notification callback used by direct action execution, not during entity creation or plugin precompilation. The system-triggered plugin and listener are valid.
I’ll check the latest plugin executions before replacing the unsupported direct callback test with an end-to-end webhook test.
Plan correction: No recent plugin execution exists because the ServiceNow event path has not been triggered yet. The failed direct action test uses a notification callback that is not reliable in the action executor.
I’ll cancel that test and use the real supported path: ServiceNow webhook → listener → system plugin → notification. The developer will validate it with a real assigned incident and a valid link.
Updated verification: I will not retry the failing callback executor. The corrected plan keeps the completed implementation and provides a real end-to-end validation using a ServiceNow assignment event.
You will need to assign one real test incident during validation. Ready for your approval.
Checking: I’ll verify whether the ServiceNow configuration message was delivered and recover the exact instructions.
Location: Step 4 was delivered as a separate instruction message titled “Configure the ServiceNow incident assignment webhook.” It was not automatically created in ServiceNow because no ServiceNow configuration connector was available.
ServiceNow configuration:
- Open the Tool Studio listener service_now_incident_assigned_listener.
- Copy its webhook endpoint and authentication details.
- In ServiceNow, create an Outbound REST Message:
- Name: Moveworks Incident Assignment Webhook
- HTTP method name: post
- Method: POST
- Endpoint: the listener webhook URL
- Authentication: the listener authentication details
- Header: Content-Type: application/json
- Create a Business Rule on the Incident [incident] table:
- When: After
- Insert: enabled
- Update: enabled
- Conditions:
- assigned_to changes
- assigned_to is not empty
- Advanced: enabled
- Use this script:
(function executeRule(current, previous) {
var assignee = current.assigned_to.getRefRecord();
var incidentLink =
'https://xxxxxxxx.service-now.com/incident.do?sys_id=' +
current.getUniqueValue();
var payload = {
email: assignee.getValue('email'),
data: {
number: current.getValue('number'),
short_description: current.getValue('short_description'),
sys_id: current.getUniqueValue(),
link: incidentLink,
message:
'Incident ' +
current.getValue('number') +
' was assigned to you: ' +
current.getValue('short_description') +
'\n' +
incidentLink
}
};
var request = new sn_ws.RESTMessageV2(
'Moveworks Incident Assignment Webhook',
'post'
);
request.setRequestBody(JSON.stringify(payload));
request.execute();
})(current, previous);- Activate the REST Message and Business Rule after configuring the listener authentication.
03
Conclusion
I wasn’t surprised that ToolSmith was capable of creating the necessary objects in Moveworks. What surprised me was the speed — it was much faster than I expected.
I also loved that it gave me the exact configuration steps for ServiceNow. It would be very interesting to see if it provides this level of accurate guidance for every system Moveworks connects to, but that will be part of a separate test.
You must be a registered user to add a comment. If you've already registered, sign in. Otherwise, register and sign in.