What is headless customer support?

Shayan, Founder7 min read

Switchboard operator at a telephone exchange plugging one more cord into a wall of jacks, a city lit up at night through the window.

About a year ago Claude Code changed how we work with agents. Instead of a chat window that suggests code, you had an agent in your terminal that reads the repo, makes a plan, edits files, runs the tests, and keeps going until the job is done. Cursor's agent mode and Codex followed, and within a few months that was just how software got written.

Two things happened next. Adoption was fast, faster than any developer tool before it, and the models kept getting better at long tasks. An agent that could hold a plan together for ten minutes could soon hold it for an hour, then for a whole job. Once that's true, there's no reason the agent needs you sitting there. So the next step was an agent that runs without you.

Scheduled routines in Claude Code and Cursor were the first version, where a prompt fires on a timer. Grok Bot was the first one that felt like a new kind of thing, an always-on agent with its own computer in the cloud that you talk to in chat and that keeps working after you close your laptop. It landed hard, and ChatGPT Dots followed a few weeks later. That's where we are now. The agent has a machine, runs on a schedule or when an event fires, and works with whatever tools you give it access to.

What you give it access to is what it becomes. Give it the repo and it knows how the product works. Give it a read-only database and it knows what customers do. Add your CRM, your docs, and your error tracker, and a few months in, the agent knows your product better than anyone on the team because it has read all of it and doesn't forget.

It puts that knowledge to work. It opens PRs, fixes bugs from Sentry alerts, updates docs, ships features, and writes release notes. On a lot of small teams, the agent is already doing a real share of the engineering.

The one thing it can't do is reach your customers.

The missing connection

The agent sees the code, the data, and the errors, but it doesn't see the person on the other end. It can't see what customers asked for, what confused them, what they reported, or what they're waiting on. All of that lives in your support and feedback tools, and those tools were built for a person to sit in all day, not for an agent to operate.

So the agent knows everything about the product and nothing about the customers. It ships a fix without knowing who reported the bug. It writes release notes without knowing who was waiting on them. It reads the docs without knowing which questions keep coming in because a page is unclear.

That's the gap headless customer support is built to close.

What headless means

The term comes from headless Chrome, a full browser that runs without a visible window. It does the work in the background and a person checks the result later. A headless product works the same way, giving an agent a direct connection to operate it alongside your repo or your CRM. The UI is still there and your team still uses it, but it's no longer the only way in.

UserJot Headless brings that model to customer support and product feedback. Your agent connects once with an API token over the MCP server or the REST API, and gets access to the customer side of your product: live chat and the shared inbox, the feedback board, the roadmap, and the changelog. With one connection, your agent is in the loop with your customers.

What your agent does once it's connected

Connecting your agent turns the follow-up work that usually gets skipped on a busy software team into routines that run on their own.

Triage the morning inbox and follow up

Every morning, the agent reads the new conversations and requests that came in overnight, works out what each one is, tags new requests, and routes threads to the right teammate. When someone asks for a feature in chat or email, the agent checks your board and adds their vote to the existing request, or files a new one on their behalf if it isn't there yet.

If a bug report doesn't have enough detail to reproduce the issue, or a feature request is too vague to act on, the agent replies in the thread to ask what the customer was trying to do and picks the task back up when the answer arrives. Your team opens an inbox that is already sorted and clarified.

Pick up Juno's handoffs

Juno is the support agent we run inside UserJot. She handles the first line of chat and email by answering questions from your docs and the websites you point her at, searching your public feedback board to file a request or add a vote once the customer confirms, and handing a conversation to your team when it needs a person.

Your own agent picks up those handoffs because it knows what Juno doesn't: your codebase, your database, and your internal systems. It checks the actual error, looks up the customer's account, and leaves a private note with a drafted answer for your team to review and send.

Juno passes a conversation and its attached history to an agent with access to code, data, and errors.

Spot patterns across every conversation

Because the agent reads across every conversation and piece of feedback instead of handling tickets one at a time, it catches repetition that slips past a busy team. When the same question comes in ten times in two weeks, the agent recognizes a documentation gap and opens a PR to fix the docs. When five people describe the same workflow problem in different words, it adds their votes to the matching request on the board and flags any duplicate posts for you to merge. You only see those patterns if you read everything, and nobody on the team has time to read everything.

Repeated customer questions lead an agent to add an answer to the documentation.

Close the loop when code ships

Keeping the board and roadmap current is the step that almost always gets dropped after a release. When your agent ships a fix or sees a feature land, it comments on the request and updates its status, which moves it along the roadmap automatically. Marking a request Completed emails everyone who posted, voted, or commented on it, so the people who asked find out without anyone keeping a list of who to tell.

At the end of the week, the agent drafts a changelog entry from what shipped, links back to the completed requests, and leaves the draft for you to publish. The loop closes with the customers who started it.

None of this replaces your team or your inbox. Your team still works there, and Juno still runs the first line. The headless layer sits underneath so your own agent is part of the same loop, and you decide how far it goes, from reading and summarizing to leaving notes, drafting updates, and replying.

The feedback loop

Your agent is only as good as its feedback loop, and most agents only have half of one. They see the code and the database, so they know what the product does, but they don't see the customers, so they don't know whether it's the right product.

Headless support is the other half. Feedback comes in through the widget in your product, your inbox, and the board. The agent reads what people are running into, ships the fix, and closes the loop with the customers who asked for it. They respond, and the cycle starts again. The agent gets better at building your product because it hears from the people who use it.

That's why this is a layer between your agent and your customers, not another bot that talks to them. The bot was the easy part. The hard part is everything around the conversation: knowing who asked, following up, closing the loop, and feeding what you learn into the next thing you build. That's what UserJot handles, so your agent doesn't have to build it from scratch.

Where this goes

It isn't all or nothing. Some teams will run an agent that only reads and summarizes. Some will let it triage threads and leave private draft replies. Some will let it handle whole categories of conversations with a person reviewing the output. Most teams will move along that line over time as they see how the agent behaves.

The direction is set. Agents get their own machines and more access every month. Products an agent can connect to become part of the loop, while products it can't connect to become something a person has to copy information out of. Customer support has always been the second kind, and we're making it the first.

Start here

UserJot's MCP server comes with the API on every plan, including Free. Create a token in Settings under API Tokens and connect your agent with the MCP server address. Start with a routine that only reads what came in overnight, what's trending on the board, and what Juno handed off. Run it for a week, and then let it start leaving private notes and drafting updates. The headless page has the routines to copy and the setup guide for each agent. If you want to see the interactive workflow first, I wrote about connecting my feedback board to my coding agent when the MCP server shipped.