Everything we ship,the day we ship it.

The same investigate-and-fix loop as everything else in Runtime

Each recommendation opens as an incident with its reasoning and evidence, and if a safe, behaviour-preserving fix exists, Autter opens a pull request for it.

Honest when it cannot help

If nothing safe can be done automatically, the recommendation stays as guidance with its reasoning on the timeline, the same posture as a performance incident with no available optimisation.

Checked weekly, per repository

Runs on a slow, deliberate cadence, and never repeats a recommendation the reactive error, performance, or AI-cost monitors already raised.

Four depths

Documentation-only changes get a light skim, still checked for an accidentally pasted secret. Small, ordinary code changes get a lighter pass. Everything else gets the full review it always got.

Never lighter where it matters

Database migrations, CI configuration, dependency files, and anything touching authentication or billing always get the full review, however small the diff. A small change to a file used across dozens of others is escalated the same way.

Shown, not hidden

The review depth and the reason for it are printed on the check run and the gate summary, so it is never a mystery why a review came back quickly.

Every failed check comes with a specific fix line rather than a bare red mark, and a broken install now points you straight at this command instead of a general troubleshooting dump.

A reverted change no longer shows the old findings as current

Push a change that undoes every edit in a pull request, and the dashboard would briefly say there was nothing to review, then quietly bring back the previous version's findings as if they still applied. The dashboard now marks a summary as belonging to an older revision whenever that is the case, and a genuinely emptied diff is recognised and closed out immediately instead of running a full review against nothing.

The written summary now agrees with the findings table

The pass/fail wording could say no findings remain while the table right below it still listed one, because the two counted findings differently: the summary quietly excluded ones a later, more careful pass had already ruled out as false positives. Both now count the same way, and the summary explicitly says when a finding was dismissed rather than acting as though it was never raised.

Reconnecting the same repository is always fine, and nothing changes on paid plans, where swapping which repositories are connected was always intended to work. If you are genuinely stuck, upgrading remains the way through, and every screen that could previously read as an invitation to swap repositories now says plainly that it is not.

A few quieter side effects sharing the same root cause are fixed with it: empty language breakdowns, empty AI-authorship figures when a repository filter was applied, and commit summaries regenerating on every load instead of loading from cache.

Delivery is now at-least-once end to end. Your service's monitoring library retries with backoff when a send fails, and duplicate retries are recognised and only counted once on our side. A background reconciler also runs every fifteen minutes comparing what should have arrived against what actually landed, and quietly backfills anything that slipped through.

Alongside it, expanding an error group now loads its actual recent occurrences, time, route, status code, release, and trace, instead of only the frozen summary captured when the issue was first seen.

Autter's runtime library now recognises when a trace contains an error partway through and keeps the whole trace, not just the error span, so you land on the full story instead of one isolated data point. This closes the same gap already fixed for AI call traces.

That tracking now lives in the header's notification bell: a small badge while anything is running, a list of in-progress jobs you can click through to, and a permanent record left behind once each one completes.

What you see while it runs

The setup screen used to show an indeterminate progress bar while your first repository was indexed. It now shows the same plain-language stages the dashboard already had, fetching your code, reading every file, mapping how it connects, writing up what was learned, expanded from six stages to seven for more granularity, plus a live file count as it works.

One email instead of several

Connecting more than one repository at once used to send a separate indexing-complete email per repository, sometimes before the others were even done. The email now waits until every repository in the batch has finished and names the ones it is reporting on together.

That failure now recovers automatically: the connection is dropped and re-established instead of staying wedged, and the underlying cause is now logged clearly if it happens again.

"Do not ship this" comments

Phrasing like "do not merge", "remove before release", or a lingering WIP marker is flagged directly on the pull request.

Markers that admit a known problem

FIXME, HACK, XXX and similar, with no linked issue behind them, are called out as risk with no paper trail.

Disabled tests

Skipped or pending tests are flagged wherever a test suite has quietly stopped running part of itself.

A repository-wide view

Codebase scans get a new TODOs tab inventorying every marker with its age, so a note from eight months ago reads differently to one from yesterday.

A marker linked to an issue number or a ticket is treated as tracked debt, not a problem. The point is encouraging a paper trail, not banning TODOs outright.

Figures are estimates from public list pricing, so a flat-fee subscription seat will not map exactly to what you are billed, and models Autter cannot yet price are called out explicitly rather than silently left out of the total.

A normal git outcome was read as a failure

Two commits sharing no common history is an entirely ordinary answer for git to give, but the CLI treated it as an error and used that as a reason to skip attribution processing for the whole surrounding pull. It no longer does.

Local-only mode stopped writing attribution after a settings change

Switching from connected mode to local-only should move attribution storage to git notes on your own machine. Instead, the background service kept using its previous setting until restarted, so local-only installs were silently degrading to plain git blame with no attribution at all. Changing modes now takes effect immediately.

One bad rebase could poison every rebase after it

Rebasing onto history with no common ancestor, the same case as the first fix, left behind a marker that could never be resolved, and that marker was retried ahead of everything else on every later rebase, permanently blocking attribution from being restored. That marker is now recognised and skipped instead of retried forever, and repositories already affected repair themselves on their next rebase.

Server-side squash merges are now recovered automatically

When a pull request is squash-merged through GitHub or GitLab's own merge button, the resulting commit is created server-side with no attribution note attached. Autter now recognises this after your next pull and reconstructs the note from your local branch automatically, the same recovery a manual command already offered, without needing to run it by hand.

Windows installs are no longer broken

Windows binaries were missing from recent releases entirely, so the advertised download 404'd, and the PowerShell installer's architecture detection could crash outright on some machines. Windows binaries now ship with every release, and installer failures explain specifically what was tried and why it failed instead of a bare HTTP error.

npm install now works

npm i -g autter previously failed outright. The CLI now also publishes as @autter/cli, so npm i -g @autter/cli works too, still giving you the autter command.

PATH activation is reliable on first install

Following the installer's own advice to reload your shell configuration did not always put autter on your PATH, depending on which shell file you had open. The installer now writes a small activation file and prints one command, guaranteed to work, as the very last thing it does.

Separately, VS Code's built-in Copilot agent had silently stopped producing checkpoints after an editor update changed how it exposes agent hooks. `autter install-hooks` and `autter debug` now speak the current version of that integration, with a new section in `autter debug` showing exactly which link in that chain, if any, is broken. Commits authored by cloud AI agents are also now attributed consistently between `autter blame` and `autter stats`, instead of counting as untracked in one but not the other.

The page updates live

The moment that test call lands the tab reflects it, so there is no guessing whether it worked.

Or let the setup agent do it

The agent instructions now handle the wiring and run the verification for you automatically.

It learns what normal looks like

For each individual model you use, Autter learns the typical response time and raises a flag when responses start dragging well past it.

Runaway single requests get named

Any one request that costs an unusually large amount on its own gets called out, the classic sign that a prompt has quietly ballooned or an output ran away with itself.

Safe fixes arrive as pull requests

If there is a safe, behaviour-preserving improvement available, caching, trimming a prompt, capping tokens, adding a timeout or a retry, batching requests, it opens a pull request with the change for you to review.

Honest when there is no safe fix

If it decides a safe fix does not exist, it says so on the incident timeline and explains its reasoning, so you are never left wondering whether it looked.

It arrives in the same place as your budget alerts and links straight through to the full view. If your error rate climbs or new flags appear, the summary is marked as needing attention so it does not blend into the background.

Each entry shows the tokens used, what it cost, how long it took, whether it errored, and a reference you can use to dig into that specific call.

Now, when that data store is not ready yet, the tab simply shows its normal setup and getting-started view instead of an error page, and the same protection applies automatically to any future data we add, so this class of problem cannot resurface. The background monitor that was quietly failing on the same issue every sweep is fixed too. The original outage was already resolved on our side before this change shipped; this closes the door on it happening again.

Labelled for what it is

The header marks it as a Quick scan, and a tooltip explains what the deeper full sweep adds when you are ready for it.

It does not cost you a scan

The automatic first scan never uses up your monthly allowance, paid or free.

Previously a repository with a long tail of low-severity informational notes could look alarming at a glance. The headline number is now the short list you would actually work through.

In the repository summary

After indexing, the top finding sits front and centre with its description and location.

A one-time spotlight

After your organisation's first completed scan, a spotlight card names the finding directly, with the exact file and line.

The setup guide also gained a quick step to confirm the install succeeded, plus a reminder to restart your terminal so the command is found. An entire category of it did not work and I do not know why has been removed rather than documented around.

Filters behave like the real thing

As part of the same fix, filtering in the demo actually filters: choosing an environment like staging narrows the KPIs and incident list to that environment, and the Errors tab's Resolved filter returns only resolved issues. Before, every filter returned the full sample set, which made the demo feel broken even once it loaded.

Missing data no longer breaks a page

The pages handle incomplete data gracefully now, showing an empty or could not load state instead of breaking.

What changed in the flow

Setup runs during indexing

The hub is usable while the index builds in the background, not after it.

A real Windows install command

The install guide now offers PowerShell. Previously it only ever showed the Mac and Linux command, even though Windows was supported.

Onboarding finishes itself

When indexing completes you land on your dashboard a couple of seconds later, instead of the screen sitting on a green checkmark waiting for two more clicks. If indexing ran into problems Autter deliberately does not auto-advance, so the warning stays on screen where you can read it.

One GitHub step instead of two

Installing the app links your personal profile at the same time, on the same screen. Signing up used to ask you to connect to GitHub twice.

Your remaining steps became a live checklist

The finish setting up section on the dashboard is now a proper checklist with a progress bar, and each step ticks itself off automatically based on what you have actually done: a scan that has been run, the CLI detected on your machine, observability data arriving, a teammate invited, your GitHub account linked. Hints are personalised with the repository name to scan, how many teammates you have, and which GitHub account you are connected as, and the header flips to a done state when you finish. It replaces a section that previously looked half-finished, with content floating in empty space.

Two things to know

• Teammates who never install anything themselves get a new Your GitHub account card in Settings, Source Control, which is also the first place in the product where you can disconnect a personal GitHub link.
• Linking your profile during app installation needs a small configuration change on our side to switch on, and behaves exactly as before until then.

You choose how far it goes

Per source: just collect the data, investigate it, or investigate and auto-fix.

External alerts open an incident immediately

Your monitoring tool already decided the alert was worth firing, so these skip Autter's usual volume threshold. When your tool marks it resolved, Autter closes it too.

Data Sources settings is fully working

Previously a set of preview cards, now setup instructions per tool and a copyable webhook address.

The same loop, extended to latency

Detect, investigate, fix. If there is a safe optimisation, Autter opens a pull request with the change and a test proving it.

It tells you when it cannot help

If it decides the code cannot safely be optimised, it says so on the incident timeline rather than staying silent.

No nagging

An unresolved slow process will not re-alert for a week.

Import from a secret manager

AWS Secrets Manager, Doppler, and Infisical, with a Sync now button to re-pull.

Missing variables get named

Autter shows which variables your repository declares that you have not configured yet, and a failing build check names the missing variable and points you at the tab.

Write-only by design

Nothing in the product or its APIs ever gives a value back. Only variable names are ever displayed.

First scans no longer fail with a raw technical error

New users running their first codebase scan could hit a failure with an unfriendly internal error message printed directly on the dashboard. The underlying configuration gap in our processing infrastructure has been corrected and affected scans have been repaired. Beyond that, we changed the behaviour so this class of problem cannot fail a scan at all: a scan that cannot be dispatched right away now stays safely queued, and a new background sweep picks up anything waiting more than a few minutes and runs it. Internal error details go to our logs only, and you see plain-language status instead.

Failed scans stopped pretending they succeeded

A scan that failed partway through could still render a green shield, risk scores, and a No findings summary, reading as a clean bill of health when it was nothing of the sort. Failed scans now show a red indicator and a clear panel saying the scan did not finish, with the scores suppressed.

In the same pass

• The CLI install prompt no longer stacks up in three places at once.
• The Settings CLI screen recognises when you have already connected, instead of pitching a feature you are using.
• An architecture map message that implied your repository was not indexed when it was.
• Two pieces of misleading copy, one about how prompt data is stored, one about how CLI credentials work.

Every count on the page agrees

On a demo trial the page header said 7 hard blocks while the summary right below it said 10. The mismatch came from different parts of the page counting findings differently: some included findings the verification pass had already refuted, some did not. Every count now uses the same rule as the merge gate itself. Refuted findings still appear in the list, counted separately and labelled, so the arithmetic on screen adds up.

The verdict is recomputed after the deeper analysis

A test pull request with a deliberately broken import and a hardcoded API key still read 0 findings, 157 checks passed, approved and merge-ready, even though the deeper analysis pass had caught the broken import by actually running the code. The verdict had been posted earlier and nothing ever revisited it. It is now recomputed when the deeper pass completes: new problems supersede the approval with a change request and turn the check red, and if the deeper pass instead refuted the findings that were blocking, the gate re-opens. Check counts, the pill grid, and the dashboard cards all update to match.

Keys labelled fake are no longer discarded silently

API keys labelled fake or dummy were being silently discarded before detection ran, which is indistinguishable from not noticing them. They now surface as a clearly labelled low-risk note, so you can see the detection worked, and they never block a merge on their own.

Effort spent where a patch can help

The fixer no longer works on findings that no patch can resolve, things like a missing linked issue or a pull request that mixes a refactor with a behaviour change. Those now get their own checklist comment addressed to you, so you can work through your half while the agent handles the automatable half, and they no longer crowd out real fixes.

Closed pull requests are handled honestly

Ticking the fix option on a pull request that was already closed used to start a job that could never run, leaving a processing message hanging forever. You now get an immediate reply explaining that fix runs only target open pull requests, and a run that is mid-flight when a pull request closes is cancelled with a comment instead of vanishing.

The patch-safety check always uses the best model

The final safety check that decides whether a generated patch is good enough to ship was being served by the economy model on lower plans, and was withholding perfectly sound fixes. That one check is now exempt from plan-based model selection for everyone. It is a tiny call, and the wrong place to economise.

• The GitHub connection reviews pull requests and indexes your code in the cloud, but only ever sees finished commits.
• The CLI runs where the code is actually written and records who wrote each line as it happens, which cannot be reconstructed after the fact.

Meaning, not keywords

Describe the change you are looking for and matching pull requests surface even when the words differ.

Exact lookups stay instant

Pull request numbers, branch names, and author names still resolve instantly.

List and Board agree

Both views always show the same matches for the same query.

Row-level security

Autter now checks Postgres row-level security posture on any RLS-reliant stack, including Supabase, Neon, RDS, Hasura, raw SQL, Drizzle, and Prisma. Available in pull request review and as a new RLS Security tab on codebase scans.

• Tables shipped without RLS enabled.
• Policies that let everyone through.
• Views and functions that bypass policies.
• Privileged keys exposed to the browser.
• Privileged queries that trust a client-supplied id.

UI design slop

Catches the tells of unedited generated interfaces before they reach production: the stock gradient hero, filler copy, leftover Lorem ipsum and Acme Corp placeholders, emoji standing in for real icons, and buttons that look clickable but do nothing.

The measurement

Overall acted-on rate

One headline number for the repository.

Week-by-week trend

Whether the review is getting more or less useful over time.

Worst-first breakdown by check

The checks costing attention without earning it sit at the top.

In your digest

The headline number and the worst-performing check are included in the weekly digest email and Slack message.

Reviews that tune themselves

This measurement now feeds back into the reviews. A check with a persistently low acted-on rate in your repository is automatically moved out of inline comments: first into the summary, then out of the pull request entirely. Checks recover on their own if they start being useful again, and you can reverse a demotion.

Run agents on a schedule

Daily, on weekdays, or weekly at a time you choose. Scheduled agents get a digest of recent activity, open and recently merged pull requests, as context.

Agents can send email

A new Email tool is available to every custom agent. Agents can only email members of your organisation, never an outside address.

Six new starter templates

Standup Summary, Weekly Review, PR Review Digest, Changelog Drafter, Dependency Update Check, and Release Notes Drafter.

One thing to know: renaming changes the workspace URL, so older links in already-sent emails and pull request descriptions will stop resolving.

Reviews were silently not posting for some organisations

Accounts created before a settings change in mid-July stopped receiving pull request reviews around 4 August: the review job was failing partway through without reporting an error. This is fixed, and Autter now repairs this class of problem automatically. Pull requests missed during the outage need a new push or an @autter comment to be reviewed.

A secret scan could report a clean result when it never ran

If the AI provider was unavailable, the secret scanner returned an empty result that looked identical to a clean scan. Scans affected by a provider outage are now clearly marked as incomplete.

Reading a stack

Stacks built with other tools like Graphite or Sapling are detected and displayed too, clearly labelled so you always know which ones GitHub can merge for you and which it cannot.

One entry per stack

Layers group together instead of scattering across your list.

Layer map with positions

See the shape of the stack and where each pull request sits in it.

Third-party stacks detected

Graphite and Sapling stacks are labelled for what they are.

Merging a stack

Three things come with it that we think you will feel immediately.

• The merge gate now agrees with GitHub. Instead of a vague warning that a pull request below is not ready, Autter names the layer and the finding holding the stack up.
• An issue found low in a stack is no longer re-reported on every layer above it, so review comments stay readable.
• The merge confirmation names every pull request that will land with it. No surprises.

Cost

Reviews across a stack are cost-aware by default, giving full attention to the layers that need it instead of re-reviewing overlapping work several times over.

Dependency-aware layers

Splits follow the real structure of the change, not the directory tree.

Deterministic and free

The same answer every time, at no extra cost.

Quiet when it should be

No split suggested for small or self-contained pull requests.

Nothing happens behind your back

Accepting a proposal records your intent and shows the commands to create the branches. Autter never rewrites your pull request for you.

Full paths reconstructed

Works for pnpm and yarn across every common lockfile version.

Dev and production separated

Development-only dependencies no longer get mistaken for ones that ship to users.

Inventories that were empty now fill in

Some older pnpm projects listed no indirect dependencies at all and will now show a complete inventory for the first time.

Demo billing pages show the right prices again

Plan pricing in demo workspaces had drifted and was displaying figures a hundred times higher than the real thing, along with out-of-date usage limits and overage rates. Everything is realigned to the actual published pricing in both US dollars and Indian rupees, and the sample usage figures now sit sensibly within plan limits so the progress bars tell an honest story.

Error tracking is quieter and more useful

A noisy class of errors caused by browser extensions, not by Autter or your code, was being captured and mixed in with real problems, where it buried genuine regressions. We now filter that category out at the source while being careful not to hide real failures that happen to look similar. The practical effect: fewer phantom issues competing for your attention.

Reviews stop cleanly when you merge mid-flight

If you merged a pull request while its review was still generating, Autter used to keep going: finishing a review nobody would read, then kicking off its heaviest follow-up work against code that had already shipped, sometimes opening a fix pull request for a pull request that no longer existed. Autter now recognises the merge, stops in-flight work where it is safe to do so, and never queues follow-up work for a closed or merged pull request. Questions you ask Autter directly on a merged pull request still get answered, because those are intentional, not waste.

Review board

• Added a pull request board view with clear columns for review status and requested changes.
• Added drag-and-drop pull request status updates for easier review management.

Review controls

• Strengthened review blocking for high-risk issues that could cause billing or financial impact.
• Added stricter free-tier limits for pull request reviews.
• Improved feedback handling with mute controls and cleaner display behavior.

Security hardening

• Fixed security gaps around file uploads, rendered content, external page fetching, and billing edge cases.

Fix execution

• Improved fix-run notifications and failure handling.
• Fixed review environment installation issues for more reliable automated runs.

Pricing and billing

• Added dual-currency pricing with clearer subscription and cancellation flows.
• Migrated subscriptions to a new regional payment flow with support for coupons.
• Improved invoice generation so payments are reflected more reliably.

Usage tracking

• Routed coding-agent sessions through metering for better usage tracking.

• Added a dedicated account-linking flow for code hosting accounts.
• Improved onboarding reliability after account connection and app installation.
• Added copy-friendly demo setup details and a smoother guided onboarding flow.

• Added secure personal access tokens for MCP and other external tool access.
• Added the Autter MCP server with tools for reading pull requests, review results, learnings, repository health, dependency checks, and codebase insights.
• Added MCP actions for replying to review comments, resolving review threads, triggering reviews, and saving team learnings.
• Added analytics for MCP tool usage and intent capture.

Build verification

• Improved production build reliability across frontend and backend.
• Added scoped build verification for large repositories.
• Added clearer explanations when builds fail.

Automated testing

• Added automated test-plan grading and execution for uncovered test areas.
• Added disposable test databases for safer automated test runs.

Connected planning

• Improved issue syncing reliability from connected planning tools.

Schedules and notifications

• Improved timestamp handling in alerts and suggestions so scheduled checks behave more reliably.
• Improved weekly digest notification settings.

• Added richer automated pull request reviews with more checks for security, reliability, performance, testing, documentation, and production readiness.
• Improved review accuracy by learning from user replies, reactions, and repository-specific feedback.
• Added stronger secret, dependency, and vulnerability detection across review workflows.
• Added configurable security alerts and weekly team digest notifications.
• Improved automated fix flows so selected fixes can be run directly from review options.
• Made high-risk money-loss findings block merges when confirmed by AI review.
• Improved nightly vulnerability scans with clearer repository summaries and better alert delivery.

• Added support for installed and custom review agents inside the review pipeline.
• Added sample agent templates and permission controls for custom automation.
• Added post-merge automation triggers so teams can run workflows after changes land.
• Improved review session routing, isolation, and diagnostics for more dependable automation.
• Fixed build, install, and environment issues that were blocking reliable review execution.

• Improved pull request diff views with clearer findings, better navigation, and per-line authorship indicators.
• Added repository-level learnings and surfaced them in the repository overview.
• Improved onboarding with a guided demo path, interactive checklist, animations, and analytics.
• Added live issue-board updates so new issue activity appears without manual refresh.
• Connected inbound issue updates to the relevant repository board.
• Improved pull request provenance by fetching full commit history instead of partial results.
• Reduced noisy client-side errors in tracking so real issues are easier to see.
• Updated documentation and project guidance to better reflect the current product experience.

• Added engineering analytics dashboards for usage, performance, deployment activity, and team delivery metrics.
• Improved executive reporting for engineering health and delivery trends.
• Hardened sign-in and authentication flows, including safer error handling and reduced sensitive logging.
• Fixed multiple security gaps around uploaded files, rendered markdown, external fetches, and billing race conditions.

• Added stronger pull request review gates to help teams catch issues before changes are merged.
• Improved the pull request review experience with clearer loading states, better error handling, and richer review status details.
• Added line-level review comments, comment threads, and reaction support for smoother review conversations.
• Introduced an AI-powered pull request assistant chat to help users understand and act on review feedback.
• Added per-commit insights so users can more easily see what changed inside a pull request.
• Added authorship insights to show how work was created and reviewed across pull requests.
• Added required status checks so review policies can be enforced directly in the development workflow.

• Expanded automated review coverage for correctness, performance, testing, documentation, internationalization, security, and production readiness.
• Added post-review verification so low-confidence or outdated findings can be checked and cleaned up.
• Added stronger secret-detection coverage.
• Added support for external quality and security scanners in the review pipeline.
• Added a feedback loop so review findings can improve based on replies and reactions.
• Improved model selection, caching, and diagnostics for automated review sessions.
• Fixed several scanner installation, parsing, and version-detection issues.

• Added automatic re-indexing after merged pull requests so project context stays up to date.
• Added automatic handling for assistant mentions in comments.
• Improved automated fix workflows to avoid repeated or recursive runs.
• Added dependency risk alerts with configurable severity filters and team notifications.
• Added weekly KPI digest notifications for review and quality metrics.
• Improved indexing reliability and support for incremental updates.

• Improved onboarding and account connection flows for the code hosting integration.
• Improved infrastructure and deployment configuration for the production app.
• Added custom domain routing and updated deployment compatibility settings.
• Cleaned up unused analytics and deployment configuration files.
• Improved backend networking permissions and deployment options.
• Fixed documentation and connection support for the internal search and analysis service.

CLI sign-in and account setup

The old flow had too many steps and not enough guardrails. The new one uses secure authentication by default, cuts the setup path in half, and gets you into a working environment faster.

Secure CLI sign-in

No more plaintext credentials or manual config files.

Streamlined account setup

Fewer steps from signup to first scan.

Personal access tokens

Connect developer tools without sharing org-wide secrets.

AI authorship insights

autter now tracks how code was created. Every pull request shows whether a change was human-written, AI-assisted, or AI-generated. This is not a judgement. It is context. Reviewers see provenance. Leads see patterns. Nobody has to guess.

Code review

More accurate findings

Fewer false positives reaching reviewers.

Clearer comments

Suggested fixes are easier to understand and apply.

Faster fix suggestions

Less time between finding and resolution.

Infra and config security checks

Catches misconfigurations before they ship.

Improved dependency reporting

Vulnerability notifications with actionable detail.

Analytics

Pull request and repository activity metrics are now clearer and more complete. You can see what is actually happening across your codebase without building your own dashboards.

GitHub integration

• Reviewer assignment works correctly across team configurations.
• Error messaging tells you what went wrong and what to do about it.
• Code indexing is more reliable for large projects: no more silent failures on big repos.

Interactive demo workspaces

Explore a real environment without creating an account.

Smoother demo signup

Fewer steps, fewer dropoffs, faster time-to-value.

Faster org creation

New organizations spin up quicker and more reliably.

Progress notifications with direct links

Go straight to the result instead of searching for it.

Complete audit trail

Every important account and billing change is logged and traceable.

Improved deployment reliability

Fewer incidents, faster recovery.

PR review: broader, sharper, quieter

Dependency impact analysis

Reviews understand what a dependency change actually touches downstream.

Typosquatting detection

Packages that look like popular libraries but aren't get flagged before they land.

Cross-file consumer checks

Changing an API? autter checks who's calling it before approving the change.

False positive reduction

Fewer findings that waste your time. The ones that remain are the ones that matter.

Infrastructure-as-code scanning

IaC scanning is live. Terraform plans, CloudFormation templates, and Kubernetes manifests are now checked for misconfigurations before they ship. Three engines run independently, so coverage gaps from any single scanner get caught by the others. If you have ever deployed a security group that was wider than you intended, this is for that.

Finding detail modals

Every finding opens into a full explanation, not a one-line summary.

AI fix suggestions

Ask autter for a recommended fix directly from any finding.

Business logic invariant views

The specific rule, the specific violation, and the specific evidence.

Content-shaped loading states

Scan results load progressively instead of appearing all at once.

Plan tiers and subscriptions

Pick a plan, upgrade or downgrade, and usage adjusts automatically.

Hosted checkout

Pay without leaving autter, with UPI and B2B invoicing included.

Invoice generation and backfill

Current and historical invoices available on demand.

Usage visibility

Your current usage is always visible in the sidebar and billing settings.

PR review engine

Chapter generation

PRs are broken into reviewable chapters, not treated as a single diff.

Inline comments

Review findings appear exactly where the code changed.

Summary utilities

Every PR gets a structured overview before a reviewer opens a file.

Gate panels and overview UI

Merge-blocking status is visible, not buried in a check run.

Local and Fargate runners

Review runs wherever your infrastructure already lives.

Fifteen review checks

Static security. CI/CD security. API contract validation. Dependency and license compliance. Typosquatting detection. Secret scanning. Infrastructure-as-code misconfiguration. Race condition analysis. Logging hygiene. Privacy surface detection. Rate limiting coverage. Architectural conformance. Policy engine evaluation. AI slop detection. Each check writes to its own findings surface, and policy violations get deterministic hashes so repeated findings are tracked, not duplicated.

PR review UI

Monaco-based diff viewer

Diffs render with the same engine your editor uses.

Conversation timeline

Comments, suggestions, and gate decisions in chronological order.

Keyboard shortcuts

Navigate reviews without reaching for a mouse.

Activity feed styling

Review events are scannable instead of a raw log.

Comments, mentions, and GIFs

Inline comments now support full Markdown. Mentions are wired in. The GIF picker is live. This is the kind of feature that makes review conversations feel like conversations instead of form submissions.

Delivery logging

PR events are logged with enough detail to debug routing.

Writeback detection

autter's own comments no longer trigger recursive review processing.

Gate-skip tracking

See what bypassed enforcement and when.

Automatic schema bootstrapping

New repos need no manual setup before gates start working.

PR review pipeline

Diff parsing and summaries

Every PR gets a structured breakdown before review agents run.

Merge-blocking review gates

Review output is evaluated before a pull request is allowed to merge.

Durable PR tracking

Revisions, metadata, and migration safeguards for org databases.

GitHub-native webhooks

PR, review, and comment events route through rebuilt handlers.

Secret scanning, rebuilt on TruffleHog

Detection runs across full git history, not just the current state. The previous version found secrets. This one tells you which ones are live, which ones rotated, and where in history they first appeared. Semgrep rule coverage also expanded across auth bypass, injection, cryptographic misuse, SSRF, XSS, and more.

Scan sharing and reports

Public share tokens

Generate a link anyone can view without an autter account.

Branded report pages

Shared reports look like they came from your security team, not a raw tool.

PDF export

Structured sections with branded cover and closing pages.

Supply chain and dependency risk

Deterministic risk scoring

Severity and risk factors are reproducible, not model-dependent.

Lockfile-aware resolution

autter resolves what you actually installed, not what your manifest says.

Exploit chain tracking

Critical CVEs with no published fix get chain cards, detail views, and narratives.

Also in this release

• The codebase-scan chat experience is now powered by AI SDK.
• Documentation generation uses task-specific model routing: each writer gets the model best suited to its job.
• Fullscreen viewing and copy support across architecture-map surfaces.

Scan infrastructure

Agent pipeline tables

Every agent's output is tracked, counted, and attributed.

Runtime preflight checks

Agents verify the environment before executing, not midway through.

strace runtime tracking

Runtime behavior is observed and stored alongside static findings.

The scanners

• Secret scanning with live validation, allowlists, rotation mapping, and direct issue creation.
• CodeQL is live as a fourth scanning engine; SAST findings include enrichment and suggestions.
• Trivy container scanning, unified dependency audits, and richer license findings.
• AI slop detection: hallucinated imports, placeholder logic, and low-confidence outputs.
• Per-organization SBOM artifacts with CycloneDX support and file risk history through commits.

Bidirectional sync

Issues created in autter stay in sync with your issue tracker.

External issue creation

Push a finding to your tracker directly from autter.

Sync logs

Every sync event is recorded and auditable.

Backfill support

Historical findings can be synced, not just new ones.

EPSS + CVSS scoring

Exploit probability and standardized severity attached to each CVE.

OSV and Exa enrichment

Vulnerability databases and external intelligence feed into findings.

Complexity scoring

Findings are ranked by how hard they are to exploit.

Exploit chain tracing

Connected vulnerability paths are tracked as chains, not isolated findings.

Documentation engine

Manual generation trigger

Teams can regenerate docs on demand, not just on scan.

Job status tracking

Generation progress is visible, not a black box.

Type-safe modular internals

A pipeline we can extend without breaking things.

Wiki and architecture

• Wiki search powered by proper full-text indexing, with better navigation, zoom, and typography.
• Architecture visualization inside generated documentation.
• File content surfaced directly in search results.

Agent execution improvements

Batch inserts + parallelism

Findings write in bulk and agents run concurrently without contention.

Team context

Agents know which team owns a scope before they score it.

Calibrated risk scoring

Scoring is tuned against actual severity signals.

Also in this release

• Custom teams and member assignment, managed directly from settings.
• A dedicated repository issues tab.

Codebase graph construction

autter maps the structure of your repo before generating any docs.

Dependency edge tracking

Relationships between modules are first-class inputs to generation.

Module clustering

Related code is grouped before documentation is written.

Risk flag integration

High-risk areas surface in the docs, not just in findings.

Recurring background checks

Your dependencies are checked on a schedule, not on request.

Concurrency controls

Multiple repos can be scanned without stepping on each other.

Graceful shutdown handling

Long-running checks no longer leave findings half-written.

First-class findings schema

Vulnerabilities and upgrade suggestions are data, not log lines.

• The repository page rebuilt around dedicated tabs: activity, dependencies, API data, health, onboarding.
• Org-wide search with suggestions, page-visit awareness, and an animated header trigger with rotating prompts.
• Deeper dependency intelligence with automatic registry and version enrichment.
• AI response caching, Vercel AI Gateway migration, and loading skeletons across the repo experience.

Also in this release

• Richer treatment for third-party packages: classification, docs resolution, usage insights.
• Endpoint indexing across multiple frameworks, connected to test coverage.

Also in this release

• Configurable event-based notifications, weekly digests, and Slack/webhook test flows.
• Shipped agentic-sales, a small open-source AI sales toolkit, as a side project.

Reverse dependency analysis

autter knows what depends on what, in both directions.

Call graph analysis

Function-level relationships are tracked across the codebase.

Scope dependency graphs

Coupling and layering between scopes are visible, not implied.

AI-augmented health and risk

Structural issues, hotspots, and tech-debt signals surface per scope.

Repository context detection

autter identifies what kind of codebase it is looking at before scanning.

Scope profiling

The indexer understands which parts of the repo relate to which others.

Full dependency resolution

The whole graph gets traced, not just top-level packages.

Scope health metrics

A health signal per scope, not just per file.

• Guided onboarding: autter asks about your setup upfront and walks you through the first scan.
• Webhook testing directly from organization settings.
• More resilient database provisioning with better retry logic.
• Stronger backend logging, health check visibility, and AI pipeline instrumentation.

What changed

• Guided organization setup: each step comes with actual context, not just a progress bar and a prayer.
• Cleaner motion and transitions across the dashboard and login experience.
• Meaningful hardening for secrets management, host configuration, and deployment setup.
• Dynamic database migrations: provisioning handles schema changes gracefully during setup.
• Better observability: improved route logging, health checks, and Slack integration.

Why it matters

First impressions compound. If setup is confusing, people assume the product is confusing. The goal is for setup to feel so unremarkable that you forget it happened. We are getting there.

What you can do now

• Start a scan from the dashboard or onboarding flow. No manual handoff required.
• Get notified when it is done, via email and Slack.
• See full dependency coverage: every package tracked, cross-referenced, and auditable over time.
• Branch-aware scanning: scans run against the right branch, not whatever was last pushed.

What gets scanned

Security vulnerabilities

Known CVEs, exposed secrets, injection patterns.

Dependencies

Every package, version, and license in your repo.

AI-generated code quality

Hallucinated imports, placeholder logic, low-signal patterns.

Blast radius

Which parts of the codebase a change touches and how far it reaches.

• Streaming progress during setup: watch organization creation happen step by step instead of waiting on a static loading state and hoping it finishes.
• The organization creation dialog now opens from the right place in the dashboard flow automatically.

Not every changelog is dramatic. Sometimes you just fix the thing that was quietly annoying everyone.

What the scan engine covers

• Security vulnerabilities in your code and dependencies.
• Open source licenses across every package you are using.
• Supply chain risk from third-party dependencies.
• Configuration problems in infrastructure definitions.
• Container security across your Docker setup.
• Policy compliance against your org's own rules.
• Business logic issues that static analysis typically misses.
• Runtime behavior signals that show how code behaves under real conditions.

• GitHub PR automation: comments, check runs, and flagged issues without leaving your workflow.
• The first analytics dashboard, with date-range filters and multiple tabs.
• Expanded codebase intelligence: hotspot detection, dependency mapping, legacy code signals.

What shipped

Authentication

Email login with one-time codes and passkeys. Trusted devices. Welcome flows.

Organization management

Teams, billing, source control, review preferences, custom agents, AI config.

GitHub integration

App installation, pull request views, and the first repository insights.

Codebase intelligence

Architecture graphs, hotspot metrics, and learning signals over time.

Dashboard and navigation

Loaders, toasts, responsive layouts, sidebars, search, and the branding system.

Captain Patch is officially on duty.