On the afternoon of August 21, 2026, [**Vercel** announced "Is Agentic"](https://x.com/vercel_dev/status/2090857388924661915), a free public tool at [is-agentic.com](https://is-agentic.com/) that grades a website on how easily AI agents can work with it. The scanning and scoring behind it belong to [Ora](https://ora.ai/blog/is-agentic-with-vercel), an agent-experience research company whose fuller ranker scores four separate layers, from discovery and access to usability and payments. Reports are readable in the browser, through a command-line tool, through a read-only JSON API, and through an MCP server.

## What the score measures, in plain English

[The scoring page](https://is-agentic.com) describes its subject as "the public parts of a website that AI agents can discover, retrieve, understand, and use." [Two tiers of checks](https://is-agentic.com/) produce the number:

- **Essential checks** are where the bulk of the points live. They cover what the page calls "fundamentals such as server-rendered content, correct HTTP behavior, clear document structure, recoverable errors, and usable controls."
- **Recommended checks** switch on only when the scan finds evidence of "an API, OAuth flow, GraphQL endpoint, MCP server, developer portal, or commerce surface." A check that does not apply is dropped from the calculation rather than marked failed, so a content site loses no points for lacking a checkout or a developer portal.

Reports also attach what Is Agentic calls an "observed agent journey," a recorded attempt by a single agent to use the site, along with the friction it ran into. That recording sits outside the number, since a single task cannot stand in for every agent or every goal, and it is often the most legible evidence in the report.

The reason this class of measurement exists at all: assistants and coding agents fetch pages the way crawlers do. They read the raw HTML response, and most do not execute JavaScript. A page whose content only appears after scripts run, or whose error pages only render client-side, is partly invisible to them regardless of how it looks in a browser.

## What we shipped

The announcement landed on Friday afternoon. By Sunday morning, the following changes were live on one of our partner sites. Each of these is measured, current work, not a plan.

**Markdown from the same URL.** Public pages now return Markdown when a client sends the `Accept: text/markdown` request header, at the same URL that serves HTML. The implementation follows the [Accept: text/markdown convention](https://acceptmarkdown.com/): a `Vary: Accept` response header so shared caches keep the two representations separate, a `406` response when a client accepts neither format, and quality-value handling per [RFC 9110's content-negotiation rules](https://www.rfc-editor.org/rfc/rfc9110#section-12.5.1). Pages also advertise a `.md` sibling through `<link rel="alternate" type="text/markdown">`, because some agents follow an advertised link rather than negotiate. Is Agentic's own report pages serve Markdown at the same canonical URL, which is a reasonable signal of where the convention is heading.

**Real 404 documents.** A dead URL returned a not-found page whose visible text, before JavaScript ran, was 27 characters. A complete prerendered 404 document existed the whole time; the routing configuration never let an unmatched path reach it. Dead URLs now serve that full document, with recovery links an agent can read in the initial HTML response. The status code was always correct. The document behind it was not.

**An `llms.txt` file with boundaries.** We added a when-to-use section listing the work the business takes on, and, as deliberately, what it does not do, since a stated boundary routes an agent as usefully as a stated capability. Two honest labels belong on this item: [`llms.txt` is a proposed convention](https://llmstxt.org/), not a standard, and [Google states it does not use `llms.txt`](https://developers.google.com/search/docs/fundamentals/ai-optimization-guide) for its AI features. We ship it as low-cost signage for the agents that do read it, and claim nothing more.

**One identity node, not two.** An automated recommendation from a scan suggested adding an `Organization` block to a site whose existing JSON-LD already declared a `LocalBusiness` node. On [the schema.org type hierarchy](https://schema.org/LocalBusiness), `LocalBusiness` is a subtype of `Organization`: the node already is one. Adding a sibling would have created two competing identity nodes for the same business. We kept one node and recorded why, then reported the check itself: on August 21 we sent Vercel the report URL, the affected endpoint, the expected behavior and a curl reproduction, which is what [its contact page asks for](https://is-agentic.com/contact). An automated reply told us that published address is not monitored for product reports, so we cannot say the correction reached anyone. This is the pattern worth generalizing: a scanner's finding is a claim to verify against the primary source, not an instruction to follow.

**And the score moved.** The site scored 74 out of 100 when we started on 21 August, and 87 when we checked again on 24 August.

Two things belong beside any number a scanner produces. It measures what the scanner can observe about a site, which is not the same as whether an agent succeeds at what a visitor actually wanted. And the rubric is young enough that a future scoring change could move this number without the site changing at all — which is why the dashboard below stores the scoring-model version beside every score, rather than the score on its own.

## Putting a third party's score on a client dashboard

We maintain a platform for our partner sites that we will be announcing in the coming weeks, and it keeps a standing checklist for every site on it: robots.txt resolved per crawler token, sitemap health, structured data read rather than counted, Markdown availability. This week that checklist gained a monthly Is Agentic scan, with the score displayed on the same page each partner already reviews.

Three decisions made a third party's number safe to display, and they generalize to any external score:

1. **Store the evidence, not a summary.** Every check in the report is stored verbatim beside the score. A recomputed summary can disagree with itself month to month; the stored report cannot.
2. **Version the rubric, and refuse false comparisons.** Scoring models change. We record the scoring-model version with every run, and when two runs were scored under different models, the dashboard says the model changed instead of displaying a month-over-month difference that would compare two different rubrics.
3. **Render the unknown visibly.** A check status our code does not recognize renders in neutral grey, never in green. A new status vocabulary should arrive visible, not silently pass.

One operational note from building it, measured on August 22: the service keeps its most recent finished report on hand and serves that, and its own guidance tells you to rescan once a fix ships. A monthly job therefore has to request a fresh scan rather than re-read the stored result. A dashboard number that never moves reads as "nothing regressed," which is worse than no number.

## The benefit, without overstating it

Is Agentic states its own limit plainly, telling readers to "use the report as a prioritized technical review, not as a guarantee that every model or browser automation system will complete every task." We would add the equivalent restraint on outcomes. Nothing in this article claims that a higher agent-readiness score produces rankings, traffic, citations, or inclusion in AI answers. [Google's guidance for AI features](https://developers.google.com/search/docs/fundamentals/ai-optimization-guide) directs site owners back to ordinary search fundamentals, and that matches what we see in practice.

Our own server logs support the same caution about Markdown specifically. Most assistant fetches we observe request HTML, and [the convention's agent matrix](https://acceptmarkdown.com/status) currently lists the major consumer assistants as HTML-only, with the Markdown-negotiating agents concentrated in developer tools. We shipped same-URL Markdown because the marginal cost was near zero, since the content already exists as Markdown, and because the interfaces reading it are multiplying. That is optionality, honestly priced, not a traffic projection.

## Review your site's Is Agentic report with someone from the Veysey Software Solutions team

If you have any questions or would like to review your site's Is Agentic report with someone from the Veysey Software Solutions team, please [email us](mailto:cooper@veyseysoftwaresolutions.com) or [book some time on our calendar](https://calendar.google.com/calendar/appointments/schedules/AcZssZ041TFFhKz0LzQydfOipmZ3l8K-22DadOWnsRMPnLkS8TjaDIreyZ8fFxAimnDxsCeimFSvnY_3). 

Vercel's "Is Agentic" score: what it measures, and what we shipped

At 5:04 a.m. Eastern time on August 21, 2026, **Google Search Central** published a [LinkedIn notice about a change to Google's JSON-LD extraction](https://www.linkedin.com/posts/googlesearchcentral_to-bring-our-parser-up-to-json-and-other-activity-7496492350907596801-qK3H). This was a Search Central technical announcement, not an announcement from the Google Search Console product.

Google now applies one pass of HTML unescaping when it extracts JSON-LD. A value that was encoded twice, such as `&amp;amp;`, will no longer be repeatedly decoded until it becomes the intended `&`. Google advised site owners to use standard JSON or Unicode hexadecimal escapes such as `\u0026` instead of relying on repeated HTML decoding. [Google Search Central announced the parser behavior directly](https://www.linkedin.com/posts/googlesearchcentral_to-bring-our-parser-up-to-json-and-other-activity-7496492350907596801-qK3H).

## What this means in plain English

JSON-LD is a JSON-based format for linked data, commonly embedded in a page inside a `<script type="application/ld+json">` element. For Google Search features, Google recommends JSON-LD in most cases because it keeps machine-readable data separate from visible HTML and is easier to manage across larger sites. [Google explains its supported formats and JSON-LD recommendation](https://developers.google.com/search/docs/appearance/structured-data/intro-structured-data#supported-formats), while the [W3C JSON-LD recommendation defines the format](https://www.w3.org/TR/json-ld11/).

Suppose the intended organization name is **Research & Development**. These JSON strings preserve that text:

```json
"name": "Research & Development"
```

```json
"name": "Research \u0026 Development"
```

An ampersand may appear directly in a JSON string, and a Unicode escape may represent it as `\u0026`; JSON requires quotation marks, reverse solidus characters, and control characters to be escaped, not ampersands. [Section 7 of RFC 8259 defines JSON string and Unicode escape rules](https://www.rfc-editor.org/rfc/rfc8259#section-7).

This version is the risk Google called out:

```json
"name": "Research &amp;amp; Development"
```

After one HTML-unescape pass, `&amp;amp;` becomes `&amp;`, not the intended ampersand. A site that depended on multiple decoding passes can therefore send Google the wrong text even when a browser page looks normal. [Google's notice identifies double-encoded named and numeric character references as affected patterns](https://www.linkedin.com/posts/googlesearchcentral_to-bring-our-parser-up-to-json-and-other-activity-7496492350907596801-qK3H).

## What we audited today

We audited every sitemap-discoverable URL across different partner sites where we maintain or review structured data. Every URL in the audit, more than a thousand in total, returned HTTP 200; hundreds of pages contained more than a thousand JSON-LD blocks. We found zero nested HTML entities matching the cases in Google's announcement.

The check performed five steps:

1. Read each site's public sitemap, including child sitemap files.
2. Fetch the HTML returned for every advertised URL.
3. Extract every `application/ld+json` script.
4. Parse each block with a standards-based JSON parser.
5. Inspect every nested string value for double-escaped named and numeric HTML entities.

Those steps test both code and content. That distinction matters on content-managed sites because a template can be correct while an editor-entered value introduces an encoding problem later. Google likewise recommends testing structured data during development and monitoring it after deployment because templating or serving issues can break it later. [Google's structured-data introduction describes that development and post-deployment validation workflow](https://developers.google.com/search/docs/appearance/structured-data/intro-structured-data#structured-data-guidelines).

The crawl also surfaced a small number of ordinary JSON parsing failures unrelated to nested HTML entities. We separated those into remediation work rather than describing this scan as a universal structured-data all-clear.

We also added the same check as a local, on-demand regression script. It is not a continuous GitHub Actions workflow and uses zero GitHub Actions minutes; it can be rerun after code or content changes when a structured-data release warrants a full crawl.

## Examples of JSON-LD we implement

The markup has to describe the content readers can actually find on that URL. Google requires it to represent the page's main content accurately rather than introduce information hidden from readers. [Google's general structured-data guidelines define those quality requirements](https://developers.google.com/search/docs/appearance/structured-data/sd-policies#quality-guidelines).

### Local businesses

For multi-location businesses, we have implemented location-specific `LocalBusiness` objects on individual location pages, using supported facts such as the canonical location URL, address, hours, geographic coordinates, and price range. Google documents these properties for local business pages and may use them in business details shown in Search or Maps; complete and accurate data remains more important than filling every optional field. [Google's LocalBusiness documentation lists the supported business details](https://developers.google.com/search/docs/appearance/structured-data/local-business).

### Products, offers, and product ratings

For ecommerce pages, we have implemented `Product` and `Offer`, adding `AggregateRating` only when the rating is specific to that product and visible on the page. Google says product structured data can make a page eligible for richer appearances that include price, availability, review ratings, shipping information, and other product details. [Google's Product documentation describes those search appearances](https://developers.google.com/search/docs/appearance/structured-data/product), and [Google's review guidelines require marked-up ratings to be visible and tied to a specific item](https://developers.google.com/search/docs/appearance/structured-data/review-snippet#technical-guidelines).

### Organizations

We have implemented `Organization` data using the official name, URL, logo, and verified public profile relationships rather than blank or speculative values. Google says Organization markup can help it understand and disambiguate an organization, and that properties such as `logo` can influence visual elements in Search results and knowledge panels. [Google's Organization documentation explains those uses](https://developers.google.com/search/docs/appearance/structured-data/organization).

### Articles and breadcrumbs

On publication and professional-services sites, we have implemented `Article` or `BlogPosting` data for the headline, author, date, and representative image, plus `BreadcrumbList` data for the page's position in the site hierarchy. Google says Article markup can help it understand article details and show better title, image, and date information, while breadcrumb markup helps Google categorize a page in search results. [Google documents Article structured data](https://developers.google.com/search/docs/appearance/structured-data/article) and [Breadcrumb structured data](https://developers.google.com/search/docs/appearance/structured-data/breadcrumb).

## The benefit, without overstating it

Correct structured data can clarify a page's meaning for Google and establish eligibility for supported enhanced search features. Eligibility is not a promise that a feature will appear; if Google applies a structured-data manual action, the consequence concerns rich-result eligibility rather than the page's ordinary web-search ranking. [Google states both limitations in its general structured-data guidelines](https://developers.google.com/search/docs/appearance/structured-data/sd-policies).

The same restraint applies to claims about AI-generated search answers. For AI Overviews and AI Mode, Google directs site owners back to ordinary Search requirements; it does not prescribe an AI-specific Schema.org vocabulary. Structured data should still agree with the visible page. [Google's guidance for AI features states those requirements directly](https://developers.google.com/search/docs/appearance/ai-features#seo-best-practices).

Our recommendation is therefore narrow: produce valid JSON-LD from accurate, visible content; use supported types where they describe the page; and test the rendered output whenever templates or content systems can change it. Today's parser change did not require a live rewrite across the audited partner sites, but it justified a complete rendered-site check and a repeatable regression tool.

## Request a JSON-LD findings report

Want a clearer picture of the JSON-LD your site is serving? [Let us know](mailto:cooper@veyseysoftwaresolutions.com). We can crawl the public URLs listed in your sitemaps, parse the JSON-LD returned in the page HTML, and share a concise report of parsing failures, encoding problems, conflicting markup, and prioritized next steps.

## Thank you for your time

If you have any questions or want to connect on anything that I wrote about above, please [email me](mailto:cooper@veyseysoftwaresolutions.com) or [book some time on my calendar](https://calendar.google.com/calendar/appointments/schedules/AcZssZ041TFFhKz0LzQydfOipmZ3l8K-22DadOWnsRMPnLkS8TjaDIreyZ8fFxAimnDxsCeimFSvnY_3). Any and all feedback is of course so appreciated.

Google's JSON-LD parser changed: what we checked

## Introduction

Last week I shared some reflections from my first few weeks using agentic coding tools [(link)](/blogs/agentic-systems-first-impressions?utm_source=coding_agent_notifications&utm_medium=blog_link). Today I am going to share some details about a problem that I encountered repeatedly while using these tools, as well as a solution that I built to address that problem.

## What prompted the creation of this tool?

You assign a coding agent a long-running task and switch to Slack to answer some messages. You start and finish a huddle and eventually return to your IDE to find that the coding agent has been sitting idle for several minutes, because it requires your direction on a task or authorization to use a tool. If you had known that the agent required your input, then you would have provided the required input quickly and had the agent back to work several minutes prior. Instead material time and output have been lost to unnecessary latency.

When Claude Code requires input from a human, by default that is communicated exclusively via Claude Code outputting a message to the terminal. It is not otherwise announced that Claude Code requires feedback in order to continue its work. No sound plays, no visual notification displays outside of what is displayed via the terminal.

That means that if a human is not actively monitoring their terminal, there is a delta between when an agent requires feedback and when a human becomes aware of that. Repeated dozens of times across a workday, the cumulative cost of these idle intervals adds up. A few minutes here and there compounds into hours of idle agent time, which can prove extremely expensive as measured by throughput.

This was happening to me often enough that I was compelled to explore how other folks had accounted for this. The consequences felt significant enough that I was sure that a quality solution to the problem must exist already. I was excited to find and start benefitting from that solution.

I validated that I was not the only person to experience this problem, for example [this Reddit thread](https://www.reddit.com/r/ClaudeAI/comments/1ll8f3d/can_claude_code_play_a_sound_when_it_requires_an/) is dedicated to the problem and features comments like:

> Sometimes (Claude Code) works for a couple of minutes and I don't want to stare at the screen waiting for it to (stop) inevitably and ask me something to approve etc. Is there a way to play a sound when it requires my attention?

> Getting a sound alert when Claude Code needs your approval would totally keep you from staring at the screen all day waiting for the next prompt.

I learned that several coding agent alert solutions exist, but none were exactly what I was looking for. Some require manual JSON editing. Others offer audio alerts but not visual notifications, which is not viable for folks like myself that are frequently on calls and often need to silence their audio notifications. So I decided to build what I was looking for.

## What does the tool do?

- Our tool helps ensure that you are alerted as early as possible whenever a coding agent might benefit from your input. It does this via customizable audio and visual notifications that are triggered by different coding agent events.
- Our tool frees you from having to actively monitor whether or not a coding agent requires your input.

## How does it work?

Our solution takes advantage of Claude Code hooks to deliver notifications when designated events occur. Anthropic defines these hooks as "user-defined shell commands that execute at various points in Claude Code's lifecycle. Hooks provide deterministic control over Claude Code's behavior, ensuring certain actions always happen rather than relying on the LLM to choose to run them" ([source](https://docs.claude.com/en/docs/claude-code/hooks-guide)).

**Hook events that our solution currently accounts for**

- [Notification](https://docs.claude.com/en/docs/claude-code/hooks-guide#hook-events-overview) – Runs when Claude Code sends notifications.
- [Stop](https://docs.claude.com/en/docs/claude-code/hooks-guide#hook-events-overview) – Runs when Claude Code finishes responding.
- [PreToolUse](https://docs.claude.com/en/docs/claude-code/hooks-guide#hook-events-overview) – Runs before tool calls (permission prompts).
- [PostToolUse](https://docs.claude.com/en/docs/claude-code/hooks-guide#hook-events-overview) – Runs after tool calls complete.
- [SubagentStop](https://docs.claude.com/en/docs/claude-code/hooks-guide#hook-events-overview) – Runs when subagent tasks complete.

**Some details on what happens when our app is installed**

Script files are added to ~/.claude/scripts/:

- smart-notify.sh — Parses hook event metadata, invokes afplay for audio playback and
  terminal-notifier for macOS notifications.
- select-sound.sh — Determines which audio file to play based on event type and project.
- read-config.sh — Loads notification preferences from audio-notifier.yaml, and exports
  them as shell environment variables.
- audio-notifier-uninstall.sh — Removes hooks from settings.json, deletes installed
  files, creates a timestamped settings.json backup.

The below files are added to ~/.claude/:

- audio-notifier.yaml — Configuration file storing event-specific notification settings,
  audio file paths, and Focus mode behavior.
- .sounds-enabled — Flag file checked by smart-notify.sh to enable/disable notifications.
- voices/global/\*.mp3 — Pre-generated audio files for default notification sounds.
- terminal-notifier.app — macOS utility for delivering native system notifications via
  NSUserNotificationCenter.

## Customization options

We created a <a href="https://v2.tauri.app/" target="_blank" class="inline-link">Tauri</a> app to make it as easy as possible for users to customize their coding agent notifications experience. Via our GUI:

- Visual notifications can be turned on and off on a per event basis.
- Audio alerts can be turned on and off on a per event basis.
- You can arrange for different audio to play on a per event basis.
- You can upload custom audio for your alerts.
- You can customize how [Apple "Focuses"](https://support.apple.com/guide/mac-help/change-focus-settings-mchlff5da36d/mac) (Do Not Disturb, Work, Sleep) affect your notifications.

These settings are stored locally in YAML and can be modified either through the GUI or directly via the config file.

## Video that showcases the tool

<div style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; margin: 20px 0;">
  <iframe
    style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"
    src="https://www.youtube.com/embed/KT1uzZtKu-8?si=N0HREHVEeP74QAKi&vq=hd2160&quality=highres"
    title="Coding Agent Notifications Demo - Visual and Audio Alerts for Claude Code"
    frameborder="0"
    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
    referrerpolicy="strict-origin-when-cross-origin"
    allowfullscreen
    loading="lazy">
  </iframe>
</div>

## Installation

It takes less than 60 seconds to install and start using our solution. The app needs to be opened once in order to enable notifications, after that the app does not need to be running in order for notifications to fire. Claude Code sessions that were started before the application is run for the first time will need to be restarted, due to the fact that ~/.claude/settings.json is read once at session startup.

<p style="margin-top: 20px; margin-bottom: 8px;"><strong>Option 1</strong></p>

<style>
.download-button {
  display: inline-flex !important;
  align-items: center !important;
  justify-content: center !important;
  gap: 6px !important;
  padding: 14px 28px !important;
  background-color: #000000 !important;
  color: #ffffff !important;
  text-decoration: none !important;
  border-radius: 12px !important;
  font-weight: 600 !important;
  font-size: 16px !important;
  transition: all 0.2s ease !important;
  margin: 20px 0 !important;
  border: 1px solid #000000 !important;
  line-height: 1.5 !important;
}

.download-button:hover {
  background-color: #1a1a1a !important;
  color: #ffffff !important;
  transform: translateY(-1px) !important;
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15) !important;
  text-decoration: none !important;
}

.download-button:visited {
  color: #ffffff !important;
}

.download-button svg {
  flex-shrink: 0 !important;
  margin-left: -2px !important;
}
</style>

<a href="https://github.com/cwveysey/coding-agent-notifications-releases/releases/latest/download/Coding-Agent-Notifications-Installer.dmg" class="download-button" target="_blank" rel="noopener noreferrer">
  <svg width="20" height="20" viewBox="0 0 20 20" fill="currentColor" xmlns="http://www.w3.org/2000/svg" aria-label="Download">
    <path d="M2.66821 12.6663V12.5003C2.66821 12.1331 2.96598 11.8353 3.33325 11.8353C3.70052 11.8353 3.99829 12.1331 3.99829 12.5003V12.6663C3.99829 13.3772 3.9992 13.8707 4.03052 14.2542C4.0612 14.6298 4.11803 14.8413 4.19849 14.9993L4.2688 15.1263C4.44511 15.4137 4.69813 15.6481 5.00024 15.8021L5.13013 15.8577C5.2739 15.9092 5.46341 15.947 5.74536 15.97C6.12888 16.0014 6.62221 16.0013 7.33325 16.0013H12.6663C13.3771 16.0013 13.8707 16.0014 14.2542 15.97C14.6295 15.9394 14.8413 15.8825 14.9993 15.8021L15.1262 15.7308C15.4136 15.5545 15.6481 15.3014 15.802 14.9993L15.8577 14.8695C15.9091 14.7257 15.9469 14.536 15.97 14.2542C16.0013 13.8707 16.0012 13.3772 16.0012 12.6663V12.5003C16.0012 12.1332 16.2991 11.8355 16.6663 11.8353C17.0335 11.8353 17.3313 12.1331 17.3313 12.5003V12.6663C17.3313 13.3553 17.3319 13.9124 17.2952 14.3626C17.2624 14.7636 17.1974 15.1247 17.053 15.4613L16.9866 15.6038C16.7211 16.1248 16.3172 16.5605 15.8215 16.8646L15.6038 16.9866C15.227 17.1786 14.8206 17.2578 14.3625 17.2952C13.9123 17.332 13.3553 17.3314 12.6663 17.3314H7.33325C6.64416 17.3314 6.0872 17.332 5.63696 17.2952C5.23642 17.2625 4.87552 17.1982 4.53931 17.054L4.39673 16.9866C3.87561 16.7211 3.43911 16.3174 3.13501 15.8216L3.01294 15.6038C2.82097 15.2271 2.74177 14.8206 2.70435 14.3626C2.66758 13.9124 2.66821 13.3553 2.66821 12.6663ZM9.33521 3.33333C9.33521 2.96606 9.63298 2.66829 10.0002 2.66829C10.3674 2.66847 10.6653 2.96617 10.6653 3.33333V10.8939L12.8625 8.69661L12.967 8.61165C13.2252 8.44092 13.5766 8.46925 13.804 8.69661C14.0633 8.95628 14.0634 9.37744 13.804 9.63704L10.47 12.97C10.3453 13.0947 10.1765 13.1653 10.0002 13.1654C9.82388 13.1654 9.65425 13.0948 9.52954 12.97L6.19653 9.63704L6.11157 9.53255C5.94101 9.27441 5.96924 8.9239 6.19653 8.69661C6.42382 8.46932 6.77433 8.44109 7.03247 8.61165L7.13696 8.69661L9.33521 10.8949V3.33333Z"></path>
  </svg>
  Download for macOS
</a>

<p style="margin-top: 20px; margin-bottom: 8px;"><strong>Option 2 (terminal)</strong></p>

<div class="minimal-code-block">
  <code>curl -fsSL https://cooperveysey.com/install.sh | bash</code>
  <button class="minimal-copy-btn" onclick="copyCommand('curl -fsSL https://cooperveysey.com/install.sh | bash', this)" aria-label="Copy to clipboard">
    <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5">
      <rect width="13" height="13" x="9" y="9" rx="2" ry="2"/>
      <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
    </svg>
  </button>
</div>

<style>
.minimal-code-block {
  display: flex;
  align-items: center;
  gap: 8px;
  margin: 16px 0;
  padding: 10px 12px;
  background: #fafafa;
  border-radius: 4px;
  font-family: 'SF Mono', 'Monaco', 'Consolas', monospace;
}

.minimal-code-block code {
  flex: 1;
  font-size: 13px;
  color: #24292f;
  background: transparent;
  padding: 0;
}

.minimal-copy-btn {
  background: transparent;
  border: none;
  cursor: pointer;
  padding: 4px;
  display: flex;
  align-items: center;
  opacity: 0.6;
  transition: opacity 0.2s;
}

.minimal-copy-btn:hover {
  opacity: 1;
}

.minimal-copy-btn svg {
  color: #57606a;
}
</style>

<script>
function copyCommand(text, button) {
  navigator.clipboard.writeText(text);
  const originalHTML = button.innerHTML;
  button.innerHTML = '<svg width="18" height="18" viewBox="0 0 16 16" fill="none"><path d="M13.78 4.22a.75.75 0 010 1.06l-7.25 7.25a.75.75 0 01-1.06 0L2.22 9.28a.75.75 0 011.06-1.06L6 10.94l6.72-6.72a.75.75 0 011.06 0z" fill="#57606a"/></svg>';
  setTimeout(() => {
    button.innerHTML = originalHTML;
  }, 2000);
}
</script>

## Accounting for [Apple Focuses](https://support.apple.com/guide/mac-help/change-focus-settings-mchlff5da36d/mac)

Our visual notifications are delivered via <a href="https://github.com/julienXX/terminal-notifier" target="_blank" class="inline-link">terminal-notifier</a>, a utility for delivering native macOS notifications. By default, visual notifications are suppressed if a Focus (Do Not Disturb, Work, Sleep) is active. Follow the instructions below if you would like for our visual notifications to display regardless of whether a Focus is active.

- <a href="x-apple.systempreferences:com.apple.Focus-Settings.extension" class="inline-link">Open Focus Settings</a>.
- Select the Focus that you want to allow coding agent visual notifications for.
- From there select **Allowed Apps** from the **Allow Notifications** section, and add terminal-notifier to that list.

## Future plans for the tool

If other folks wind up using the tool and have feedback, I will definitely consider accounting for said feedback. I am also open to open-sourcing the tool.

I hope that the tool proves useful to at least a few other individuals — that would bring me a ton of joy. I enjoyed building this and learned a lot in the process. I continue to be amazed by what these coding agent tools can do.

**Backlog**

- Support for additional coding agents
- Support for Linux
- Allow for per-project customization
- Notification badges, subtle dock indicators
- Slack notifications, phone notifications (e.g. see https://justin.searls.co/posts/notify-your-iphone-or-watch-when-claude-code-finishes)
- "Smart" escalation rules (e.g. if no response after x time, ping y other channel)

## Thank you for your time

If you have any questions or want to connect on anything that I wrote about above, please [email me](mailto:cooper@veyseysoftwaresolutions.com) or [book some time on my calendar](https://calendar.google.com/calendar/appointments/schedules/AcZssZ041TFFhKz0LzQydfOipmZ3l8K-22DadOWnsRMPnLkS8TjaDIreyZ8fFxAimnDxsCeimFSvnY_3). Any and all feedback is of course so appreciated.

Receive notifications for designated coding agent events

> Like any truly disruptive technology, AI agents have the power to reshuffle the deck. Done right, they offer laggards a leapfrog opportunity to rewire their competitiveness. Done wrong—or not at all—they risk accelerating the decline of today's market leaders. This is a moment of strategic divergence. While the technology will continue to evolve, it is already mature enough to drive real, transformative change across industries.
>
> — [McKinsey, "Seizing the agentic AI advantage" (June 2025)](https://www.mckinsey.com/capabilities/quantumblack/our-insights/seizing-the-agentic-ai-advantage)

## What prompted me to start using agentic coding tools?

Earlier this month I attended a [Claude Code](https://docs.claude.com/en/docs/claude-code/overview) workshop that [Alex Lieberman](https://x.com/businessbarista) and [Arman Hezarkhani](https://x.com/ArmanHezarkhani) from [Tenex](https://www.tenex.co) hosted. Prior to that event I had never actually experimented with Claude Code or watched a formal demo of the tool, despite having seen it mentioned countless times online. What I observed during the workshop motivated me to install Claude Code and explore its capabilities firsthand. I was particularly interested in how my coding efforts might benefit from:

- Parallelism (agents working through separate tasks concurrently, as opposed to an individual task being worked through one step at a time via a chat interface like ChatGPT)
- Autonomous task completion (e.g. via sharing requirements with an AI, having the AI write tests in accordance with said requirements, having the AI execute the aforementioned tests and iterate on implementation approaches until all relevant tests are passing)
- Providing AI with expanded codebase context (providing an AI access to, except where I restrict things purposefully, an entire project rather than just snippets that I manually paste into a chat interface)
- Providing AI with a wider range of tooling capabilities, as compared to what it has access to via a traditional chat interface (empowering the AI to execute scripts, capture and analyze screenshots across window sizes, directly edit files, create and analyze browser logs, download and make use of designated third-party packages, take advantage of [MCPs](https://www.anthropic.com/news/model-context-protocol), etc)

I assigned Claude Code some tasks and put it to work on some portfolio site improvements that I had been meaning to get around to. I was stunned by

- How significantly the aforementioned agentic capabilities impacted my development experience.
- Claude Code's performance as measured by task completion quality and speed.

Claude Code has since become a tool that I use every day, and agentic AI systems have dramatically changed my approach to writing code, building software, and to completing work more generally.

## What exactly are AI agents—and what does "agentic AI" mean?

I'll include some relevant definitions from OpenAI and Google below. [OpenAI defines agents as](https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf):

> systems that independently accomplish tasks on your behalf. A workflow is a sequence of steps that must be executed to meet the user's goal, whether that's resolving a customer service issue, booking a restaurant reservation, committing a code change, or generating a report.
>
> ...an agent possesses core characteristics that allow it to act reliably and consistently on behalf of a user:
>
> 1. It leverages an LLM to manage workflow execution and make decisions. It recognizes when a workflow is complete and can proactively correct its actions if needed. In case of failure, it can halt execution and transfer control back to the user.
> 2. It has access to various tools to interact with external systems—both to gather context and to take actions—and dynamically selects the appropriate tools depending on the workflow's current state, always operating within clearly defined guardrails.

[Google defines agentic AI as](https://cloud.google.com/discover/what-is-agentic-ai?hl=en):

> an advanced form of artificial intelligence focused on autonomous decision-making and action. Unlike traditional AI, which primarily responds to commands or analyzes data, agentic AI can set goals, plan, and execute tasks with minimal human intervention. This emerging technology has the potential to revolutionize various industries by automating complex processes and optimizing workflows.

## How does using agents differ from using ChatGPT?

Let's use an analogy to illustrate the difference.

**Baking a cake without agentic tools**

- A human describes their desired result to ChatGPT. ChatGPT replies with step-by-step instructions that the human is responsible for executing. The human procures the ingredients, preps the kitchen, completes all required measuring and mixing, operates the oven and oversees the baking process, and completes all required cleanup.
- If something goes wrong, the human describes the problem to ChatGPT, ChatGPT provides feedback, and the human takes action in accordance with said feedback.

In this example, AI (ChatGPT as a traditional AI chat interface) serves as a guide and provides direction - a human is required to execute the AI's instructions. In this example the AI is reactive (it replies to prompts), it does not actively monitor progress and it generates text as its output.

**Baking a cake with agentic tools**

- A human shares their desired result with an agent, and provides the agent with access to all relevant tools (e.g. car keys for driving to the store, a credit card for purchasing groceries, an alarm code for entering the house). The agent takes things from there and identifies viable recipes, procures the ingredients, and completes all required prep, baking, and cleanup.
- Before the agent presents the finished cake to the human, it validates that the cake meets the success criteria that were defined by the human. If during its testing the agent identifies any issues, at that point the agent will iterate until the cake satisfies all success criteria.

In this example, AI completes work autonomously, it actively monitors progress and makes adjustments as needed, and generates a cake that meets the specified success criteria as its output.

## The Goldman Sachs CIO on their first experience using "one of the new agentic coding tools"

> Early models, for all their fluency, felt like they were operating with a kind of impostor syndrome, optimized for credibility over correctness. But then came the inflection point, a step-change brought about by a new class of "reasoning" models. Suddenly, we weren't just conversing with a statistical machine that predicted the next word in a sequence;
> we were getting a peek into a nascent form of cognition.
>
> The first time I experimented with one of the new agentic coding tools, I felt that familiar spark of magic. I tasked it with a personal project I'd never found the time for: migrating a charity website from a simple web builder to a proper, modern CI/CD environment. For the next twenty minutes, it went to work, asking clarifying questions, requesting credentials, and providing status updates. It felt less like using a tool and more like collaborating with a junior developer. When it presented me with a fully deployable package, complete with impeccable documentation and unit tests, I was floored.
>
> Of course, it wasn't perfect. It made mistakes. It got stuck. It required my supervision and, crucially, my judgment to steer it back on course. The experience drove home a lesson I've learned the hard way over a long career: you cannot afford to trust blindly. Yet, the process was fascinating. Peeking into its "chain of thought" was like watching a mind at work—messy, non-linear, full of starts, stops, and self-corrections, not unlike our own human reasoning. It wasn't a straight line; it was a random walk toward a solution. Here was the kernel of something new: not just an intelligence that could generate content, but one that could generate a plan.
>
> This is the promise of agentic frameworks. It's the difference between a static subway map and a dynamic GPS that reroutes you in real-time. A classic rules-based automaton follows a fixed path; when it encounters an unexpected obstacle, it breaks. An AI agent, powered by a reasoning model, has the potential to observe, adapt, and find another way. It possesses a form of digital common sense that allows it to navigate the countless edge cases of reality. It represents a shift from simply telling a computer "what" to do, to explaining "why" we need something done and trusting it to figure out the "how."
>
> — Marco Argenti, CIO of Goldman Sachs, excerpted from Antonio Gullí's ["Agentic Design Patterns: A Hands-On Guide to Building Intelligent Systems"](https://docs.google.com/document/d/1PWhaXD_UNKgJaxYe3JBxRFRt3_B8Wm67CFxtSBQ4LkU/edit?tab=t.0)

## Further reading

Because there is broad consensus that agentic AI qualifies as a paradigm shift and a historically significant innovation, fortunately there is no shortage of high-quality agentic systems-related learning material for anyone looking to get up to speed. I'll share some resources below for both engineers and non-engineers.

**An accessible introduction to Claude Code and agentic coding for non-engineers**

I thought that [this "Claude Code for Non-Coders | A Complete Beginner's Guide" YouTube tutorial](https://www.youtube.com/watch?v=S5ULIoThOIM) was notably well done (topics covered, pace, structure, thoroughness, ease of understanding, audio quality). It walks viewers through installing and setting up the software that is required to take advantage of Claude Code (e.g. an IDE like Cursor, Node.js), showcases how to interact with Claude Code using natural language to facilitate your desired result, and demonstrates how to "save progress" to GitHub and deploy an application to publicly accessible URLs via Vercel.

If while watching the tutorial you find yourself confused by any terms or concepts, try sharing a description of what you find confusing with ChatGPT or another LLM. Also please feel free to [drop me a line](mailto:cooper@veyseysoftwaresolutions.com).

**Agentic coding resources for folks that have an engineering background**

- I would recommend experimenting with Claude Code if you have not done so already. [Here](https://docs.claude.com/en/docs/claude-code/overview) is a link to the Claude Code developer documentation. And [here](https://anthropic.skilljar.com/claude-code-in-action) is a link to a free course that Anthropic put together, that "provides comprehensive training on using Claude Code for software development tasks, covering the underlying architecture of AI coding assistants, practical implementation techniques, and advanced integration strategies."

  For reference, Anthropic is the company that created and maintains Claude Code. In September 2025 Anthropic announced a $13B raise at $183B post-money valuation. Anthropic is considered one of the leading AI labs, as measured by e.g. model performance and product innovation.

- I haven't completed [this "Agentic AI" course](https://www.deeplearning.ai/courses/agentic-ai/) but decided to share it here anyways. It was created by [Andrew Ng](https://www.linkedin.com/in/andrewyng). Andrew founded Coursera (NYSE: COUR), was the Director of the Stanford AI Lab, and started the Google Brain team. The course is intended to provide "a fundamental understanding and practical knowledge to develop production-ready agentic applications, from design patterns to deployment and evaluation."

**Some agent-focused pages from leading tech companies**

[Amazon](https://aws.amazon.com/blogs/machine-learning/enabling-customers-to-deliver-production-ready-ai-agents-at-scale), [Google](https://google.github.io/adk-docs/), [IBM](https://www.ibm.com/think/topics/ai-agents), [Meta](https://metait.ai/agentic-ai/), [Microsoft](https://learn.microsoft.com/en-us/shows/ai-agents-for-beginners/), [NVIDIA](https://blogs.nvidia.com/blog/what-is-agentic-ai/), [OpenAI](https://academy.openai.com/public/clubs/builders-etkn1/videos/unlock-agentic-power-with-the-agents-sdk), [Oracle](https://www.oracle.com/artificial-intelligence/generative-ai/agents/), [Salesforce](https://www.salesforce.com/agentforce/ai-agent-course/), [Snowflake](https://www.snowflake.com/resource/a-practical-guide-to-ai-agents)

**Additional resources**

- The print version of "Agentic Design Patterns: A Hands-On Guide to Building Intelligent Systems" by Antonio Gullí is scheduled for release in December 2025. [Here](https://www.amazon.com/Agentic-Design-Patterns-Hands-Intelligent/dp/3032014018) is an Amazon link for the print version, and [here](https://docs.google.com/document/d/1rsaK53T3Lg5KoGwvf8ukOUvbELRtH-V0LnOIFDxBryE/preview) is a link for a free digital version that is available now.

  The book "provides the essential knowledge and practical examples to not only understand the 'what' and 'why' of agentic systems, but also the 'how'" ([quote from Google VP Saurabh Tiwary](https://docs.google.com/document/d/18Q9kfZuCTL37ztrSjLxwf8Elr5UfAiAavmnj0IqSpbU/edit?tab=t.0)). Gullí is a "Distinguished Engineer" at Google, he leads strategic initiatives for Google Cloud's "Office of the CTO."

- ["How Agentic AI is Transforming Enterprise Platforms"](https://www.bcg.com/publications/2025/how-agentic-ai-is-transforming-enterprise-platforms) from the Boston Consulting Group (October 2025).

- ["Real AI agents and real work"](https://www.oneusefulthing.org/p/real-ai-agents-and-real-work) by Wharton professor Ethan Mollick (September 2025).

- ["Seizing the Agentic AI Advantage"](https://www.mckinsey.com/capabilities/quantumblack/our-insights/seizing-the-agentic-ai-advantage) from McKinsey (June 2025).

- ["The agentic commerce opportunity: How AI agents are ushering in a new era for consumers and merchants"](https://www.mckinsey.com/capabilities/quantumblack/our-insights/the-agentic-commerce-opportunity-how-ai-agents-are-ushering-in-a-new-era-for-consumers-and-merchants) by McKinsey (October 2025).

- "What Is an AI Agent?" is the title and subject of [this May 2025 "What Is an AI Agent?" podcast](https://open.spotify.com/episode/4bdl6uzpdQbaXLFdO8XHMF?si=4454c3ea8bdf4c47) by Andreessen Horowitz partners [Guido Appenzeller](https://x.com/appenz), [Matt Bornstein](https://x.com/BornsteinMatt), and [Yoko Li](https://x.com/stuffyokodraws).

- [r/AI_Agents](https://www.reddit.com/r/AI_Agents) - A subreddit dedicated to AI agents that as of 10/19/2025 has 159k members.

## Thank you for your time

If you have any questions or want to connect on anything that I wrote about above, please [email me](mailto:cooper@veyseysoftwaresolutions.com) or [book some time on my calendar](https://calendar.google.com/calendar/appointments/schedules/AcZssZ041TFFhKz0LzQydfOipmZ3l8K-22DadOWnsRMPnLkS8TjaDIreyZ8fFxAimnDxsCeimFSvnY_3). Any and all feedback is of course so appreciated.

Welcome to our blog