Resolv

The part that usually goes wrong is threading. A reply lands as a new ticket, the agent answers the wrong thread, and the customer receives three disconnected emails about one problem. Resolv matches an inbound reply to the conversation it belongs to instead of opening a duplicate, and sends its own replies with the headers that make a mail client stack them together. The customer sees one conversation. Nobody had to think about it.

Inbound mail arrives on a webhook and outbound goes through Resend, so email intake and notifications both depend on that being configured. The portal and the widget keep taking tickets regardless.

They sign in with a link sent to their email. No password to invent, no password to forget, no password for you to reset at 9am on a Monday. It is the single change that removes the most support work from a support product, which is the sort of thing worth doing on purpose.

Customers are data subjects scoped to your organization, not agent seats. They never touch the agent application, never see another customer's ticket, and never count toward the plan's agent limit.

Articles live in categories and sections — enough structure for a few hundred pieces without becoming a filing project — and each one is either public or internal. Public articles are what customers search and what the widget suggests mid-question. Internal ones are for your own team: the escalation path, the refund rule, the thing everybody has to look up and nobody remembers. Same editor, same search, different audience.

Search ranks by relevance rather than listing everything containing the word. Each article carries a helpful / not-helpful control, so you find out which answers actually work instead of guessing. And articles are versioned, so an edit is recoverable.

One corpus feeds three places: the agent's sidebar suggestions, the portal's search and the widget's in-typing hints. There is no separate help site to keep in sync.

Logo, colours and the portal address are configuration. One brand on the included tiers; running several distinct brands over one team and one queue is a Pro capability.

Scores roll up three ways — by agent, by team, and over time. A single rating is noise and everyone knows it. A trend for one agent, read next to their volume and their resolution time, is a coaching conversation with evidence in it. That is the difference between a metric you act on and a number you put in a slide.

Surveys can be turned off entirely if you would rather not ask.

Six states carry it from arrival to close, alongside priority, type, tags, an assignee and a team. The distinction between pending and on hold is not bookkeeping — pending means waiting on the customer and it pauses the response clock, on hold means waiting on something else. A team is never judged on the days it spent waiting for an answer it had already asked for.

Three panes: the queue on the left, the conversation in the middle, and everything known about the customer on the right — their history, and the articles that might answer them. One screen, no tab-switching, no going back to a list and losing your place. The list keeps its position while you work through it, which sounds small until you have scrolled back to row forty for the ninth time.

They fill in what changes — the customer's name, the ticket number — and they can do things when applied: set a status, assign to someone, add a tag. "Thanks, escalating this to billing" becomes one click instead of writing a sentence, changing a dropdown, picking a person and adding a label.

Macros can be personal or shared with the team, which is how one agent's good answer becomes everyone's.

Views can be personal or shared, so a team lead can decide what the team looks at when they start the day and everybody is looking at the same thing. Ownership is checked when one is deleted — a shared view cannot be removed by someone who does not own it.

Merging folds the duplicate into the original with the whole conversation intact and in order — and it either completes entirely or does not happen at all. There is no state where half a conversation has moved and the agent is looking at a ticket with a hole in it.

Collision detection is the fix, and it is quietly one of the most valuable things in a shared inbox: each agent sees who else has the ticket open, and sees when the other is typing. Live, no refresh, no thinking about it.

An administrator defines those fields once in settings. They appear on the ticket form, they are stored with the ticket, and they can be filtered on in views and reports like anything else. Adding one is a configuration change, not a deployment.

Two decisions about it are worth knowing before you buy.

It runs on your own provider key. Your key, your visible usage, your control over the spend. Nothing is resold to you at a markup, and you can see exactly what the AI costs you.

It is priced inside the seat, not per resolution. The industry is moving toward charging per ticket the AI touches, and the predictable result is a team that hesitates before using the tool bought to make them faster. A fixed seat price removes that hesitation, which is the whole point of having it.

Customers hear when their ticket is received, when someone replies and when it is resolved. Agents hear when a ticket is assigned to them, when a target is about to be missed, when they are mentioned in an internal note, and when something escalates to them.

Every tier has these. They answer "how are we doing".

Teams do two jobs, and both matter more than they sound.

Team creation and membership changes are checked server-side, not just hidden in the interface.

Resolv runs a real one. You set first-response and resolution targets per priority; every ticket carries a live countdown an agent can see; the system warns before a target is missed and escalates when one is. And the clock respects a business-hours calendar — timezone and holidays included — so a ticket that arrives at six on Friday evening is not quietly burning through its target all weekend. It also pauses while you are legitimately waiting on the customer.

That is the difference between a target a team can actually meet and a number that exists to be missed. Breach detection runs on a schedule, so a cron caller is a real requirement: without one the countdown still displays and nothing ever escalates.

Two kinds, and the second is the one people forget. Event rules fire on something that happened: a ticket was created, assigned, or breached its target. Time rules fire on something that has not happened — a ticket has been pending for more than a day, so send a reminder. Most tickets that die quietly die that second way.

Rules are built in a form rather than dragged around a canvas, and the trade is deliberate: you give up arranging boxes with a mouse and you get a rule that is readable at a glance and still understandable to whoever inherits it in six months. Actions are the same ones an agent has by hand — set a status, assign, tag, notify, reply.

SLA compliance as a percentage rather than a feeling. Satisfaction as a trend line instead of a snapshot. A peak-hours heatmap showing when your queue actually arrives — which is usually the single most actionable chart in a support operation, because it turns "we're always behind" into "we're understaffed on Tuesday mornings". An agent leaderboard, and CSV export for anyone who wants the raw numbers in their own spreadsheet.

That split — everyone gets the scoreboard, the analytical layer is the upgrade — is the honest place to draw the line.

Keys are managed in-app and rate-limited like every other route in the product.

An agency supporting three clients, or a company with two product lines that shouldn't look like one — each gets its own branded portal, its own address and its own look, while the agents work a single queue and never switch tools. The alternative is running three installations and reconciling them by hand.

Creating a ticket properly means validating the input, writing the record, recording an audit entry and dispatching the events that trigger everything downstream. Through an ordinary REST API that is the caller's job to sequence correctly, and the caller usually gets it slightly wrong. Connect verbs — create, close and assign — do the whole sequence in one call, with a declared step plan and a single audit row.

The same verbs are published as tools an AI agent can call directly through a machine-readable manifest. So an assistant elsewhere in your business can file and route support work without a person copying it between two screens, and without you writing an integration to make that possible.