What's new in Watari

Before Watari pushes a draft PR, it now runs the build your repository already uses, so Java, Kotlin, Rust, Ruby and every other language get the same check TypeScript, Python, Go and C# had. A draft nothing could check says so on the PR.

• Watari reads your build from your CI definition (GitHub Actions or Azure Pipelines) and runs it in an isolated sandbox, once on your branch and once with the fix. When a fix breaks your build, Watari sees the errors and tries again before your team sees the PR.
• Prefer to say it yourself? Add a build command, and an optional setup command, in the repository's settings. It is used instead of Watari's built-in checks.
• Every draft PR now has a Validation section that says what was checked. When nothing could be checked, it says the draft is not validated and how to change that.
• Your CI still comes first: where your pipeline already builds Watari's pull requests, its result is the check.

When your CI fails on a draft PR Watari opened, Watari reads the error and pushes a fix commit to that branch, on GitHub and Azure DevOps alike. On by default.

• A draft PR your team opens should already build. When a compiler error, lint error or failing test shows up on a Watari draft, Watari pushes one follow-up commit that fixes it and says so in a comment on the PR.
• It only touches its own work: Watari fixes a failure on a commit it pushed itself and never builds on top of anyone else's. If someone pushes while Watari is working, nothing is written.
• It only acts on code: a package feed, network or build agent problem gets no commit, and a failure it already tried to fix is not tried again.
• The same behaviour on GitHub and Azure DevOps. Turn it off or allow up to five fix commits per PR in Settings, AI and pipeline, under Fix failing CI on draft PRs.

The billed unit is renamed Mapped Issue, because a code-actionable feature request now counts the same as a bug. Tickets and Requests are one Issues list with a type switch.

• The unit you are billed for is called a Mapped Issue: a bug, or a code-actionable feature request (a specific change to code you already have), paired with the file and function Watari ranks as the most likely cause. Nothing about your bill changes with the name.
• An open-ended feature request, and any question, is never mapped and never billed. It is still filed to your issue tracker.
• Tracker sync is never billed. Filing to Jira, Linear, GitHub Issues or Azure Boards stays bundled, whatever those tools call the record they create.
• The sidebar used to carry Tickets and Requests as two entries pointing at the same list. They are now one Issues entry with a Bugs / Requests / All switch on the page itself, the way Linear, Jira and GitHub all shape it.
• The list moved from /tickets to /issues so the address bar matches what the product calls it. An old /tickets link no longer resolves. The meter doc is now /docs/billing/mapped-issue-meter, and the old doc URL redirects.

Before writing a fix, Watari now searches your repository to confirm which file actually carries the defect, so a fix can land in a file the mapping stage never picked.

• Searches the repository before drafting, instead of trusting the ranked guess
• A fix can now edit a file that was not in the mapped locations
• Skipped on follow-up commits, which already know the file they are changing

HTML, Handlebars and Go templates, PostCSS, and dependency manifests like package.json and go.mod are now indexed, so a bug whose fix edits one of them can be mapped to it.

Protocol v4 scores 120 pre-registered cases across eight new repositories, every one of them out of sample, and reproduces the previous result rather than improving on it.

The embedding phase reports queue position and an estimated finish time instead of showing a spinner that could not distinguish waiting from stuck.

Running Connect again on GitHub or Azure DevOps keeps everything else you had set on that integration, including the Azure event channel, and a one-click repair restores event delivery.

Each language in a repository is labelled parsed, text-chunked or not indexed, and documentation no longer triggers a coverage warning it was never a shortfall in.

Integrations that are connected but have never received a single ticket are flagged in Settings, with the setup step that is usually missing.

Four changes to how Watari searches your codebase, measured on the published benchmark: the top ranked file is one the merged fix actually changed in 36 of 56 cases, 64.3%, with a 95% interval of 51.2% to 75.5%. The first published run scored 8 of 17, 47.1%, on a smaller sample.

• A whole class of function was invisible to the indexer: anything defined by wrapping a call, which is how most handlers, hooks and factories are written. Those bodies are now indexed.
• A ticket describes a symptom and code implements a mechanism, so the search now also looks for the mechanism the symptom implies rather than matching the customer's words against source.
• Each repository gets enough search depth for the right file to reach the ranking step, instead of being cut off by a shared budget.
• Files a fix routinely edits are indexed rather than skipped: Vue, Svelte and Astro components, stylesheets, tree-sitter queries and XML build files. Golden-file test snapshots are excluded, because they were crowding out real code.
• The number and every case behind it are at [/proof](/proof), including what got worse: repository routing went from 56 of 56 to 55 of 56. The change was chosen by looking at these same cases, so read it as a ceiling rather than as evidence it generalizes.

A pre-registered measurement of how often Watari reads a bug report and points at the file that actually had to change, with the protocol, the frozen sample and the unedited results in a public repository.

• Ground truth is the maintainer's own merged fix on public issues from six open-source projects in six languages, so a third party produced the answers before we ran anything.
• The protocol was committed before the sample was frozen, and the sample before the results. That ordering is checkable with git log in the public repository, not something you have to take on trust.
• Every case is published, hits and misses alike, with the file Watari chose next to the file the maintainer changed. Every rate carries its denominator and its confidence interval.
• It measures one step of six. It says nothing about whether the draft pull request is any good or whether the customer-facing incident report reads well, and we do not put a number on those.
• Read it at [/proof](/proof).

When build validation fails on a Watari draft, the failure is read with the file and line that failed and the fix is revised. A pull request merged outside the app is reconciled back to the bug it resolves.

Repositories and notifications belong to the workspace you have open, so each workspace shows its own data and archiving in one leaves the others untouched.

Files over the old size ceiling are now chunked and searchable, so a bug whose cause lives in a big legacy file can still be mapped.

Large monorepos index and embed to completion, and a repository that cannot finish raises a notification instead of sitting in progress.

Column-level write permissions on every table a member can touch, the multi-factor gate applied to every authenticated route, and inbound code-host webhooks bound to the workspace that owns the repository.

A second Jira connect path using an Atlassian API token, plus alerts when a tracker stops accepting what Watari files.

• Jira sites that require admin approval before an app can be installed can now be connected with an Atlassian account email and API token instead, which sits under a different admin policy. Credentials only ever go to your Atlassian Cloud site.
• A Jira project without a Bug issue type (team-managed Scrum projects have none) no longer rejects every filing: the issue type is chosen from the project's own schema.
• If a destination stops accepting issues, whether the site was deleted, the project is gone or the credentials were revoked, the integration is marked disconnected and you get told once, rather than silently failing on every bug.

Filing can be turned off per integration, so you can have your codebase indexed and pull requests drafted while nothing is ever opened in your issue tracker.

The full conversation is read rather than the latest reply, reconnecting a support tool keeps your configuration, and each provider account keeps its own tickets distinct.

Watari now reads whatever your customer sent: PDFs, screen recordings, voice notes, logs, HAR captures, CSVs and Office documents, not only images.

• Screenshots and screen recordings are read visually, and a recording's narration is transcribed too. The clearest description of a bug is often something the customer said out loud while reproducing it.
• PDFs are read page by page, including scans with no text layer, so an invoice or an exported report attached to a ticket is evidence rather than a download link.
• Logs, HAR captures, stack traces, CSVs and Office documents are read as text and quoted verbatim into the bug report. A stack trace's real error is at the end, so long files are trimmed from the middle and the omission is marked.
• Zendesk tickets used to lose any file attached to the opening description when an agent's reply fired the webhook, and Freshdesk tickets lost every reply past the tenth. Both now reconcile against the full conversation.
• Archives are still stored for download and deliberately not opened.

Azure DevOps (Azure Repos) joins GitHub as a supported code host, the full ticket-to-draft-PR pipeline now runs on Azure DevOps at parity with GitHub.

• Connect Azure Repos in Settings → Integrations through Microsoft Entra ID: tenant-backed OAuth with short-lived, admin-revocable tokens, not a personal access token. Pick your organization, project, and repository.
• Full pipeline parity with GitHub: index the repo, map each bug to the responsible file and function, open a draft pull request, watch build validation, and hold the customer-facing RCA until an Azure Pipelines production stage confirms the deploy.
• Your branch policies run untouched: Watari publishes the draft so build validation and required reviewers apply exactly as they would on a human-opened PR. Watari never bypasses a policy.
• Optionally add Watari's service principal to your organization to have pull requests authored by "Watari" instead of the connecting user, the way Renovate and Copilot operate on Azure. Skip it and PRs are simply human-authored; nothing depends on it.
• Mix GitHub and Azure DevOps repositories in one workspace, a bug is routed to whichever repositories its code actually lives in, regardless of provider.

Per-bug status-change emails are now opt-in and off by default, so your inbox stays quiet unless you ask for them.

The customer-facing RCA reply now reads in Watari's own first-party voice, with no AI hedging and no vendor names exposed.

Auto-generated PRs edit large files reliably: fix generation uses targeted search/replace edits, so big files stay intact.

A production-readiness pass that makes billing, recovery, and dashboard numbers trustworthy under real-world failure.

• Mapped-Bug metering and Razorpay webhooks are now replay- and retry-safe, so a redelivered event can never double-bill you.
• Watchdogs recover repositories stuck mid-index or mid-mapping instead of leaving them wedged.
• Every outbound provider call is wrapped in a timeout and circuit breaker, so one flaky third party can't cascade.
• Dashboard metrics show real deltas: placeholder and estimated numbers were removed.

Freshdesk joins Zendesk and Intercom as a supported support tool, escalated tickets flow into the same ticket-to-draft-PR pipeline.

• Connect in Settings → Integrations by pasting your Freshdesk domain and API key, validated live against your account.
• Inbound tickets arrive over a per-tenant verified webhook you wire into one Freshdesk Automation Rule, so only escalated tickets reach Watari.
• The API key is AES-256-GCM encrypted at rest and tenant-isolated by row-level security, like every other integration.
• The customer-facing RCA is published back as a public reply on the originating Freshdesk ticket once the fix ships.

File mapped bugs into GitHub Issues alongside Linear and Jira, an explicit, opt-in destination you choose per workspace.

• Pick the destination repository explicitly, like Linear and Jira; it's off until you turn it on.
• Only bugs that clear the Mapped-Bug confidence bar are filed, and each can route to the repo it actually maps to.
• Fixes the old behavior of filing into the oldest-connected repo for multi-repo workspaces.

Connect more repositories as you grow, and let a single bug fan out into coordinated draft PRs across every repo it touches.

• Repo count scales with your plan; Growth and above unlock cross-repo PR fan-out.
• One bug that spans several repos opens a coordinated draft PR in each, routed to the right reviewers.
• Downgrades deactivate excess repos instead of deleting them, with an in-app chooser for which to keep; upgrading reactivates them.

Teammates with a matching company email domain are offered "Request to join" your workspace instead of creating a separate silo, with owner approval.

A GitHub installation now maps to exactly one workspace, and you can connect an App you've already installed instead of dead-ending on GitHub's configure screen.

Notifications are calm by default and scoped to what's yours, plus watch and subscribe so you follow the specific bugs you care about.

• Bug alerts go to the assignee first instead of blasting the whole team.
• Watch or subscribe to individual bugs to follow only what matters to you.
• Bulk emails carry one-click, standards-based unsubscribe.

A re-wired onboarding checklist on Home, clearer indexing wait times, and a gentle nudge if setup stalls.

The Tickets list now shows the client company on each row, and the detail view surfaces who's affected and how widely.

• A Customer column replaces the old quote snippet on the Tickets list.
• The ticket detail shows structured company information and the cluster's blast radius.

The draft-PR pipeline now rides out slow models, GitHub blips, and hung streams instead of failing the whole run.

• A per-installation circuit breaker keeps one workspace's GitHub trouble from affecting everyone else.
• A forgiving, self-tuning rate limiter adapts to your model provider's limits with no redeploy.
• Failed drafts can retry immediately instead of waiting out a lock.

Bugs now route to the repositories whose code actually matches, replacing a summary-based guess that could miss the right repo.

• Routing is driven by a cross-repo search over your indexed code, not a prose summary of each repo.
• PR fan-out targets are derived from the bug's ranked code locations.
• Each mapped location shows a source-repo badge, and re-mapping takes your hints into account.

Send feedback and attachments straight from the Help menu; the team triages it in an internal board.

A bounded-memory streaming indexer lets big repositories index without running out of memory, with live progress.

• The indexer streams and flushes in bounded batches, so memory stays flat regardless of repo size.
• Repos up to tens of thousands of files index cleanly; larger ones are flagged gracefully instead of failing silently.
• Watch indexing progress live, with automatic recovery if a run stalls.

A calmer, faster workspace: a borderless sidebar on a paper canvas, one floating content card, and a real Inbox.

• A dedicated Inbox route replaces the old notification bell.
• A sidebar search row opens the ⌘K command palette from anywhere.
• Settings moved into the profile menu, and a Help launcher sits in the footer.

The pipeline keeps only vector embeddings and structural metadata, your actual source is fetched on demand and discarded.

• Source file contents are no longer persisted anywhere in Watari.
• When code is needed to map a bug or draft a fix, it's fetched from GitHub at the indexed commit and thrown away.
• Tokens and secrets stay AES-256-GCM encrypted, and tenant data stays isolated by row-level security.

A public blog with practical playbooks on turning support tickets into shipped fixes and customer-facing RCAs.

A full product documentation site launched at /docs, covering setup, the pipeline, settings, and billing.

A rebuilt marketing site, complete legal coverage, and hardened sign-in landed together.

• A product-tour homepage and use-case pages.
• Full legal coverage: privacy, terms, DPA, subprocessors, and acceptable-use.
• Two-factor authentication, bot protection, and email confirmation on sign-up.

A new name and brand across every customer-facing surface.

Generated fixes are type-checked in a sandbox before the PR is drafted, catching hallucinated code before it reaches your review.

Watari extracts bugs from tickets in any language and publishes the RCA back in the customer's original language.

• Customer verbatims are preserved untouched, including mixed languages like Hinglish or Spanglish.
• Screenshots and short screen-share clips are read by a vision-aware model.

Fixes that span several repositories fan out into coordinated per-repo draft PRs, with the RCA gated on all of them merging.

Every Watari-drafted PR shows the same green/red CI signal GitHub does, mirrored into the dashboard and Slack.

• Reads the check and status events your branch protection already trusts, no new CI integration.
• The PR tab shows passing, running, or failing with a per-check breakdown.
• The Slack notification carries a live CI line that updates in place and pages reviewers on the first failure.

Leave a review comment on a Watari-drafted PR and it proposes the follow-up commit on the same branch within minutes.

• A classifier reads each comment, and only actionable feedback triggers a regeneration.
• Follow-ups are committed to the same branch: no force push, no history rewrite.
• A per-workspace iteration cap, with a Slack heads-up if the fix isn't converging.

The same issue reported by many customers clusters into a single canonical bug, one fix, one RCA fanned out to every linked ticket.

• Incoming bugs are embedded and deduplicated across all your support tools plus email.
• You're billed per fix, not per duplicate report.
• When a cluster grows, Watari pings the thread so you see the blast radius.

When a repository has no CODEOWNERS file, Watari infers likely owners from commit history and can open a one-click PR to add it.

Pay only for Mapped Bugs (a bug paired with the exact file and function responsible) with PR drafts, RCAs, and tracker sync bundled in.

• A bug is billable only when both extraction and code-mapping clear a confidence bar; the meter fires once, at persist time.
• PR drafting, customer RCAs, and Slack, Linear, Jira, and GitHub sync are bundled, never metered.
• Billed in INR for India (with GSTIN) or USD elsewhere, with GST-compliant invoices and a seven-day mismapped-credit window.

Watari writes a root-cause analysis back to the original ticket, but only after the fix actually reaches production.

• The RCA publishes on a confirmed production deploy, not just on merge.
• A later rollback parks the RCA and warns engineers.
• It's published in the customer's own language, back on the ticket where they reported it.

Draft PRs are routed to the right reviewers by reading your CODEOWNERS, with branch-protection awareness.

• Existing CODEOWNERS rules drive reviewer assignment automatically.
• Set the PR target branch per repository or per PR.

Connecting Zendesk is now one click: Watari auto-provisions the webhook and a per-tenant signing secret, with no manual setup.

Watari now turns real support tickets into structured bugs, Zendesk tickets and Intercom conversations flow in by webhook.

• Scope what reaches Watari with a Zendesk trigger tag or an Intercom team assignment.
• Each ticket is normalized and structured against a strict schema: severity, repro steps, impact, and the customer's own words.
• Non-bug tickets like billing and account questions are classified and skipped.

New ways to navigate: a Code Hotspots page, a ⌘K command palette wired to live data, and a ticket view split into Customer, Engineering, Reasoning, and Metrics lenses.

GST-compliant PDF invoices (CGST/SGST and two-zone USD), an upcoming-invoice card, and a monthly or annual billing toggle.

A realtime in-app notification center plus a full transactional email system (welcome, invites, bug and status alerts, billing, and digests) built to render correctly in Gmail.

Watari writes the fix and the test, checks them, and opens a draft PR, the core support-ticket-to-PR loop.

• An extended-thinking model drafts the patch plus a test, validated before the PR opens.
• The draft PR lands in your repository with live status in the PR tab.
• Slack notifies you when the PR is created and when it merges.

Each extracted bug is mapped to the specific files and functions responsible, with a confidence score, shown in a Code tab.

• Vector search plus a confidence-scored rerank narrow to a file-and-function pair.
• Bugs that span multiple repositories route to the right one.

Watari pulls key frames from screen-share videos attached to tickets and embeds them into the bug and any Jira or Linear issue.

Install the GitHub App, pick repositories, and Watari indexes them so bugs can be mapped to real code.

• Parsing plus embeddings build a high-recall index across more than twenty languages.
• A file browser and per-repo detail page, with re-index on demand.
• Push webhooks keep the index current as your default branch moves.

Watari now extracts both bugs and feature requests from support tickets, and files each one appropriately.

• Feature requests create Jira Stories (bugs stay Bug type) and carry a Feature Request label in Linear.
• A dedicated Requests view and a type filter keep triage clean.

The first release: a multi-tenant SaaS foundation with the dashboard, notification delivery, billing, and team management the rest of the product builds on.

• Multi-tenant workspaces with role-based access and team management.
• Delivery to Slack, Linear, and Jira.
• Razorpay billing with a free trial.
• The dashboard shell, authentication, and onboarding.