How we handle GDPR data-subject requests on a deadline
Legal
The ticket-to-KB agent we run on Kortix — clusters resolved Plain support tickets for recurring questions with no matching help-center article, drafts the top gaps as real articles from the actual resolutions, and opens a PR for a human to review and publish.
Every support team answers the same question more than once before anyone writes it down. An agent resolves a ticket, the customer is happy, and the answer disappears back into the support queue instead of becoming a help article. Weeks later the same question comes in again, gets solved the same way, and disappears again. The knowledge was generated a dozen times over; it was never captured once.
We run a ticket-to-KB agent on Kortix that reads our resolved Plain tickets every week, finds the questions that keep recurring with no article to answer them, and drafts the highest-value gaps as real articles pulled from how we actually solved them — then opens one PR. This is how new KB coverage gets written from what our support queue already knows.
The knowledge exists — it's sitting in hundreds of resolved Plain threads — but nobody has time to mine it. A support lead reviewing tickets for KB gaps manually has to remember which topics were already covered, which recurring questions are worth an article versus a one-off, and then actually write the draft from scratch. That review happens rarely, if at all, and by the time it does, the backlog of recurring-but-undocumented questions is large enough that picking where to start is its own project.
A generic AI writer pointed at "write some help articles" doesn't fix this either — it has no memory of what's already covered and nothing grounding its drafts in how the team actually resolves the issue, so it either duplicates existing articles or writes generic copy that doesn't match a real resolution.
On Kortix, a weekly cron re-prompts the same persistent session — a cloud sandbox that resumes its own ledger rather than starting cold. Each run it reads recently resolved threads from Plain, clusters them into recurring topics, checks each topic against both the KB repo's existing articles and its own ledger of topics already drafted, and picks the top gaps: recurring questions with real ticket volume and no article. It drafts each one from the actual resolutions used in those tickets, then opens a single PR against the docs repo. Nothing publishes without a human merge.
Open your Kortix workspace, start a new session, paste this prompt and send it. The agent writes the agent file, the mining skill and the weekly trigger, and opens a change request for you to review. Prefer clicks? Choose Use this template instead.
Set up a weekly ticket-to-KB agent in this workspace.
Create the agent agents/ticket-to-kb.md. Its job is to turn resolved support tickets into draft knowledge-base articles. It may use the PLAIN_API_KEY and GH_TOKEN secrets.
Create the skill skills/kb-gap-mining/SKILL.md with these rules:
Add a cron trigger weekly-kb-gap-mining to kortix.yaml. It runs the ticket-to-kb agent every Monday at 08:00 with the prompt "Load the kb-gap-mining skill and run one complete ticket-to-KB mining pass."
Tell me which of these secrets are not set yet.
Open a change request with all of it. Do not merge it.
Add a read-only Plain API key and a GitHub token for your docs repo as workspace secrets. Both are encrypted and injected into the session at runtime, scoped to this agent.
Reads recently resolved support threads, read-only.
Checks the KB repo for coverage and opens a draft PR.
Merge the change request, then start a session with the ticket-to-kb agent and send this prompt. Read the drafted articles in the pull request before you let the schedule take over.
Run one ticket-to-KB pass.
The change request added this trigger to kortix.yaml. From now on the agent
runs every Monday at 08:00. It reads its ledger in memory first, so a topic
already drafted is never drafted again. To change the time, edit the cron line,
or open Triggers in the workspace.
triggers:- slug: weekly-kb-gap-mining name: Weekly ticket-to-KB mining on: cron: "0 0 8 * * 1" run: agent: ticket-to-kb prompt: Load the kb-gap-mining skill and run one complete ticket-to-KB mining pass.The agent opens one pull request on its own branch and stops. It never pushes to the live docs branch, never merges and never publishes. A person reviews the drafts, edits them and merges what is ready. Plain stays read-only, so the agent cannot reply to or close a ticket.
Each run ends with one pull request and an updated ledger. This is what a run looks like in the session:
Read 214 resolved threads and found 17 recurring topics. 4 had enough volume and no article, so I drafted them in one pull request. 3 topics stay in the ledger below the bar.
Once it works, paste any of these into the same session.
In a separate section of the pull request, list existing articles under content/kb whose steps no longer match how recent tickets were resolved.
When a topic is a bug or a missing feature, not a how-to, list it in the pull request description instead of drafting an article.
After a KB pull request merges, compare the merged articles to your drafts and write the edits into the drafting rules in memory.
Turning support history into published documentation is a one-way trust question — from tickets to drafts is safe, from drafts to a live article is not something the agent decides — so the guardrails are built around that line:
The backlog of "we keep answering this but never wrote it down" questions now arrives as a small, reviewable PR each week, with every draft traceable back to the real tickets that produced it. The agent only clusters and drafts; the support team decides what gets published.