How TuTrocito Automated Its Most Complex Customer Support.

TuTrocito sells furniture and materials cut to measure: boards, glass, shelves, desks, whole wardrobes, each one to the exact millimetre a customer asks for. It's a lovely promise, and a brutal one for a support team. When every order is bespoke, every problem is bespoke too. No two damage claims look alike, no two "where's my order?" emails carry the same context, and the answer to almost anything lives buried somewhere in the order history.

For a while, that complexity showed up as a number nobody liked: the average customer waited five days for a first reply.

Today that same inbox is largely run by a VibeTasking agent. It has answered 70,000 emails and counting — triaging, investigating, negotiating resolutions, and filing the actions back into TuTrocito's own systems. This is how.

The inbox TuTrocito actually has

Most "AI support" demos assume a tidy world: short questions, canned answers, a tidy FAQ. TuTrocito's inbox is the opposite. Customers write in with the full mess of real life:

• "Where is my order? It was supposed to arrive last Tuesday."
• "The shelf came with a cracked corner" — with three blurry photos attached.
• "Can you cut this 40mm shorter and re-send a quote?"
• Returns, modifications, invoice questions, second thoughts about a finish.

The two biggest buckets are order status and damage claims. Both sound simple and neither is. Answering them well means knowing exactly what this customer ordered, what they paid, where the piece is right now, and what was already said to them in the last three emails. That's not a reply — that's an investigation.

What the agent does with every email

So the agent investigates. For each message that arrives, it runs the same loop a good support rep would, just faster and without ever losing the thread.

It reads the email and works out what it's actually about. It pulls the full context out of TuTrocito's systems — what was ordered, the price, the current status, and the entire prior conversation with that customer. If there are photos, it opens them. And then, crucially, it forms a judgement and acts on it.

The hard part: judging a damaged order

This is where most automations quietly give up and forward to a human. The agent doesn't.

When a customer reports damage, the agent looks at the attached photos and assesses how bad it actually is — because the right resolution depends entirely on the severity. A scuffed corner on a board that's still perfectly usable is not the same as a panel that arrived snapped in half.

So it proposes a fix that fits:

• Lightly damaged but usable → it offers a discount.
• Genuinely broken → it arranges a replacement of the affected piece.

Then it talks it through with the customer. And once they reach an agreement, it doesn't just say "I'll sort that out" — it carries out the action in TuTrocito's system: the discount, the reshipment, the status change. The loop closes inside the email thread, with no rep in the middle.

Acting without breaking things

Giving an agent the keys to issue refunds and reship orders only works if it's careful, and this is where most of the engineering went. Before it changes anything, it confirms the order data first — it never acts on a guess. After it makes a change, it re-reads the order to check the change actually took effect. And before it acts at all, it looks back through the history so it never does the same thing twice: no double refunds, no duplicate reshipments because a customer happened to send two emails in a row. When it can't verify what happened, it stops and leaves the case for a person.

That's the difference between a demo and a system you let touch real orders. The agent is trusted with the buttons that move money, not just the ones that draft text — precisely because it treats every one of them as reversible only if you check.

Knowing what it doesn't know

An agent that always answers is dangerous. An agent that knows when to stop is useful. This one is built around two honest reflexes.

When it's missing information, it escalates. If the agent can't responsibly resolve a case — the data isn't there, the situation is genuinely unusual — it assigns the ticket to a human instead of guessing. The hard cases reach a person with all the context already gathered.

When it hits a gap, it learns. Every time the agent runs into a situation its instructions don't cover, it writes the case down in a learning document. The team lead reviews those notes and approves the good ones into the agent's instructions. The next time that situation shows up, the agent already knows what to do. The playbook gets better every week, with a human deciding what makes it in.

That second reflex is the quiet superpower. The agent isn't a fixed script that slowly rots — it's a system that compounds, supervised by the people who know the business best.

The impact

The headline number is the easy one: 70,000 emails answered, covering order status, returns, modifications, quotes, and the long tail of everything else.

But the number TuTrocito cares about is response time. The average wait for a first reply went from five days to about an hour — and under 24 hours even for the cases that end with a person. The whole queue got faster, not just the automated slice.

What that bought them is more interesting than the speed itself:

• They launched phone support. With people no longer buried in the inbox, TuTrocito could finally staff a channel they'd never had the hands for.
• The support team got smaller, and the rest got promoted in place. The remaining team now focuses on what actually needs a human — sales, genuinely complex cases, and the phones.

Nobody is sitting where they were a year ago, copy-pasting order numbers into a back office. The routine moved to the agent. The people moved up.

The pattern underneath

None of this is really about furniture. The shape of the problem — high-context tickets, scattered across internal systems, that need investigation and a judgement call before you can reply — is the shape of customer support at almost any company that sells something real.

What made it work wasn't a magic model. It was an agent that could do four things a chatbot can't:

1. Reach into the systems where the answer actually lives and gather the full picture before replying.
2. Look at evidence — including images — and reason about it.
3. Take action, not just draft text: issue the refund, trigger the reshipment, update the record.
4. Escalate and improve instead of pretending to know everything.

If your support inbox looks anything like TuTrocito's — every ticket a little different, every good answer one investigation away — this is a workflow you can build.

Start with one inbox

You don't have to automate everything on day one. TuTrocito didn't. Start by pointing a VibeTasking agent at your most repetitive category — order status, say — let it gather context and draft, keep a human approving the actions, and grow its instructions from there. The learning loop does the rest. You can start it yourself — or let us build the first version with you.