By Dan Kaparski, Director of Digital Product, SYRN
At SYRN, there is no dedicated Digital Operations organization. Instead, the entire function is managed by two people: me and Jordan Gesky, our Head of CX. Together, we own the storefront, ERP integration, fulfillment flows, returns, and the reporting the rest of the business relies on to understand commerce performance.
We run Shopify for the storefront, NetSuite as the system of record, Radial for fulfillment, Loop for returns, and Pipe17 as the orchestration layer that keeps everything connected. It is a true enterprise commerce stack. It just is not supported by an enterprise-sized team. It is supported by two people.
For a while that meant the classic small-team trap: you cannot manually watch a multi-system order flow all day when you are also doing six other jobs. So we stopped trying to watch it myself and started building agents to watch it for us. The thing that made that possible is the Pipe17 MCP Server, built on the Model Context Protocol (MCP), and, for those of us who care about open standards, the first onX-enabled MCP server.
Why MCP Changed What I Could Build Alone
Most software gives you a UI for humans and an API for developers. Pipe17’s MCP server gives an AI agent a structured way to use the platform: query orders, read exceptions, pull inventory and fulfillment data, and act on it. That sounds like a technical detail. For a two-person team it is the whole game, because it means we can describe a job in plain language, hand it to an agent, and have that agent operate Pipe17 the way I would, on a schedule, without us sitting there.
We are not a large engineering org. We did not build a custom monitoring platform. We wrote instructions, pointed agents at the MCP server, and let them run. Here are the first two that earned their place.
Agent 1: Our Daily Order Automation Rate
The single number I care most about is how much of our order volume flows through cleanly without a human touching it. I call it our order automation rate, and we have an agent that calculates it every day and every week so we never have to.
The logic is simple, which is the point. The agent scopes to yesterday’s orders, gets the total count, then gets the count of orders with actionable exceptions. I taught it to exclude anything sitting in reviewRequired or onHold status, because those are orders doing what they are supposed to do, not failures. Total orders minus real exceptions gives me clean orders, and clean divided by total is the automation rate. It stores the result as a decimal so we can trend it over time.
When that number is healthy, I know the machine is running without me. When it dips, I know before anyone asks. One honest detail, because this is a real setup and not a demo: the orders page occasionally hangs on loading, and I simply told the agent that if that happens, open a fresh tab and reload the same URL. That is the kind of small, real-world instruction you can give an agent when it operates the platform the way a person does. It handles the quirk and moves on.
Agent 2: An Exception Watcher That Slacks Me Every Four Hours
The automation rate tells me the trend. The second agent tells me the moment something is actually on fire. It runs every four hours, looks at exceptions from the last six (a little overlap so nothing slips through the gap), and direct-messages me on Slack if it finds anything that matters.
The interesting part is what “matters” means, because I had to define it myself. Pipe17 does not have a literal “P0” field, and it should not, because what counts as critical depends on the business. For SYRN, a P0 is any active exception tied to our Shopify integration where the entity is one of:
- an order
- a fulfillment
- a shipment
- a return
In other words, anything standing between a customer and the thing they bought. Exceptions from the routing engine, the inventory engine, or the warehouse connector are real, but they are not the ones I need to drop everything for, so the agent filters by integration and entity type together and only pings me on the ones that block a customer order.
That distinction is the difference between an alert I trust and an alert I start ignoring. Because the agent applies my definition of critical rather than a generic one, when it messages me, I look.
What This Buys a Team of Two
I want to be precise about the benefit, because it is easy to overstate. These agents did not replace an ops team I never had. They gave me the thing an ops team provides that Jordan and I could not give ourselves: continuous attention. A brand our size, running the kind of product drops and multi-channel launches we do, generates more order-state changes in a day than one person can eyeball. Now something is always watching, it knows the difference between a real failure and a normal hold, and it escalates in the channel I already live in.
The reason it works is that Pipe17 already does the hard part, unifying orders, inventory, and fulfillment across Shopify, NetSuite, the 3PL, and returns into one place with one view of state. The MCP Server just let me put an agent on top of that single source of truth. If my order data were still scattered across four systems, no agent could make sense of it. Because it is not, a few plain-language instructions were enough.
We are not done. The same pattern, describe the job, point the agent at the MCP Server, let it run, applies to plenty of other work we currently do by hand. But the lesson so far is worth saying plainly: you do not need a big team to run operations like one. You need a system that exposes its data and actions to agents, and a clear idea of what you actually want watched. The team of two is still a team of two. It just has help now.
