[NFBCS] 6 Agents on Friday. 47 by Monday

[Jeff Bishop]

As a professional in this space myself I hear you and understand it and even agree with much of what you are saying. Again, this is about a community driven effort and not a single minded effort to try and make a difference.

From: Ty Littlefield <tyler at tysdomain.com>
Sent: Wednesday, February 25, 2026 3:43 PM
To: NFB in Computer Science Mailing List <nfbcs at nfbnet.org>
Cc: Jeff Bishop <jeff at jeffbishop.com>
Subject: Re: [NFBCS] 6 Agents on Friday. 47 by Monday


Sorry for the double email, but on thinking about this a bit more, I want to push back harder against this narrative.



I spend a lot of my time in the accessibility field. I work with people every day to help products become more accessible, and a lot of that work is nuanced discussion about design patterns, UX, and how to make everything functional regardless of ability.



I strongly believe that we should be using AI to make our lives better. It solves a lot of needs, and to outright ignore it is not the way to go.



That said, executives are trying to replace people like me. These are execs in companies who never have and never will use a screen reader. When putting out this type of content, I firmly believe that it does the entire community a disservice to suggest that exponentially increasing the number of agents somehow magically makes content more accessible and usable.



This reality is pretty obvious by going to the linked page, where there are a plethora of WCAG issues including the region label I mentioned in my prior email, regions being created where there should be none, and most notably a grid used for displaying information visually about the stats that is converted into one long line and not provided the proper aria roles to either display it as a table, or otherwise convert the information to a format that it can be more easily read.



If we're going to make claims that x agents solves accessibility concerns, they fall down rather quickly when a vibe coded page demonstrates most of the issues that professionals in this field often warn against and are fighting to solve every day.

Thanks,

Ty Littlefield (he/him/his)

  *   From Bytes to Bites<https://tysdomain.com>|
  *   Linkedin<https://www.linkedin.com/in/ty-lerlittlefield/>|
  *   Github<https://github.com/tlfdev>
On 2/25/2026 12:50 PM, Jeff Bishop via NFBCS wrote:
Hello NFBCS Members,

Taylor and I are so excited about what this project has turned out to be … Visit the community site on Github, learn about the GIT Going with Github course that is happening on March 7th and 8th and get involved. We would love your input, engagement and most importantly your contributions.

Jeff Bishop

It is early Wednesday morning. February 26th. Something went so right over the past five days that my brain will not stop replaying it.
Let me take you back to Friday night.

How a Frustrated Friday Night Became a Movement

Friday Night on Discord
I was working on a project. I do not even remember what it was. Something with Claude Code, like most of my nights. And I was on a Discord call with some friends, just talking while I worked.
Then something happened in the code that just set me off.
ARIA roles placed wherever the model felt like putting them. No logic. No structure. Just ARIA sprayed across the page like decoration. Inputs without labels. Modals with no focus trapping. Divs pretending to be buttons. The same failures I have been correcting for months. Every single session.
I had enough.
I had enough of fixing ARIA by hand. I had enough of inaccessible code shipping as the default. I had enough of correcting these AIs over and over and getting the same broken output the next time I asked. You know the feeling. It is too much. At some point you stop asking nicely and you start building.
So that is what I did. I decided to build a team of AI agents. Not one model trying to remember everything. A team. Specialists. Each one responsible for one piece of accessibility that it cannot forget, because that is the only thing it knows.
I had no idea what I was getting into.
I was just trying to solve a problem for myself. I wanted Claude to actually write accessible code without me having to babysit every line. That is it. I did not set out to build a forty-seven agent system across three platforms with a GitHub organization and a website and a press release. I was just frustrated on a Friday night.
Of course, I tried other things first. I tried skills in Claude Code. They activate maybe 10 percent of the time without manual intervention. I tried writing detailed instructions in CLAUDE.md files. They work at first, but as the conversation grows, they drift. The model deprioritizes them. It decides other things matter more. Accessibility gets quietly dropped from the plan. Every time.
So, I built agents instead. Six of them. I published a preview post that night, shared the repo, and went to bed.
By Saturday morning, this thing had already outgrown what I imagined. And it did not stop there.

This Is Not Just Me

I need to say this up front because it matters more than anything else in this post.
This is not my project anymore. It never should have been just mine. The moment it stopped being one person yelling into the void and became a team of people building together, everything changed. The scope changed. The quality changed. The ambition changed. The whole thing became something I could not have built alone. And that is the point.
Accessibility has always been a community fight. One person cannot cover every screen reader, every browser, every framework, every assistive technology, every lived experience. That is why the project moved to a GitHub organization called Community Access. That is why it is MIT licensed. That is why it costs nothing. Because the more people who touch this, the better it gets for the people who need it.

Jeff

Jeff Bishop and I were talking on Friday night. That is how this started. I was venting about AI tools forgetting accessibility, and Jeff was right there with me. We were already in the same conversation when I published the preview post and shared the repo.
By Saturday morning, Jeff was not just talking anymore. He was building. I did not expect what happened next.
Jeff did not open an issue or send a message saying nice work. He started pushing code. Within hours he was deep in the codebase, moving faster than I could keep up. By the end of Saturday, he had more commits than I did.
That is not an exaggeration. Look at the git log. Forty-three commits from Jeff in five days. He saw what I was trying to do. He saw where it needed to go. And he went there.
Jeff is blind. Like me, he uses assistive technology every day. He is not reviewing accessibility as an abstract checklist. He is living it. When he builds an agent that enforces focus trapping in modals, it is because he has been trapped in modals. When he writes rules for screen reader announcements, it is because he has sat in silence waiting for an announcement that never came.
That shared experience is what made this work. We did not have to convince each other that accessibility matters. We just had to build.

The Hooks Problem

Now let me explain hooks, because if you read my preview post on Friday, I made hooks sound like the answer to everything. They were not.
A hook in Claude Code is a script that fires every time you send a prompt. Think of it like a checkpoint. Before the AI starts working, the hook looks at what you asked and decides if extra rules should apply. If the task involves UI code, the accessibility agents activate. If it does not, they stay out of the way. That was the idea. And on Friday night, it worked.
The problem arose when we tried to make hooks work for everyone. Not just me on my Mac. Everyone. On every platform and different Claude Code version.
Hooks are fragile. They break across platforms. The JSON schema kept changing. PowerShell on Windows handled them differently than bash on Mac and Linux. Some hooks fired when they should not have. Others did not fire when they should have. We spent hours debugging output formats, timeout issues, and schema mismatches.
Jeff and I merged pull requests fixing hooks. A pull request is how you propose a change to code on GitHub. Someone reviews it, approves it, and it gets merged into the main project. We merged pull requests fixing hooks. Then more pull requests fixing the fixes. Then more fixing those. It was a cycle. Every time we thought we had it, something else broke.
On Tuesday, Jeff made a decision I did not expect. He removed all of them. Every hook. Every hook file. Every hook reference in every documentation file. Gone.
He replaced them with something better. Instead of hooks intercepting prompts, orchestrator agents now coordinate the team through explicit contracts. Each agent returns structured output with confidence levels so the next agent knows exactly what it is getting. Nothing gets lost between steps because the contracts define exactly what goes in and what comes out.
It is cleaner. It is more reliable. And it works on every platform without platform-specific debugging.
That is the kind of decision that only happens when someone is deep enough in the code to see the real problem. Jeff was deep enough by Saturday afternoon.

What It Was

On Friday, Accessibility Agents was six agents in a personal GitHub repo under my name. An accessibility lead, an ARIA specialist, a modal specialist, a contrast master, a keyboard navigator, and a live region controller. It supported Claude Code. That was it.

What It Is Now

Forty-seven agents across four teams. Three platforms. Fourteen shared knowledge modules. Fifty-two pre-built prompts. A GitHub organization. A dedicated website. One command to install.
The web accessibility team alone has sixteen agents. ARIA, modals, contrast, keyboard navigation, live regions, forms, alt text and headings, data tables, link text, cognitive accessibility, mobile accessibility, design systems, guided audits, testing guidance, and WCAG reference.
There is a document scanning team that covers Word, Excel, PowerPoint, PDF, and EPUB files. Forty-six built-in rules for Office documents. Fifty-six for PDFs. It generates VPAT compliance reports. It exports findings to CSV with links to help documentation so people know exactly how to fix what it finds.
There is a markdown documentation team that scans files across nine accessibility domains.
There is a GitHub workflow team with eleven agents for PR review, issue triage, daily briefings, analytics, and repository management.
It runs on Claude Code, GitHub Copilot, and Claude Desktop. It installs with one command on macOS, Linux, and Windows. It is free. It is MIT licensed. It costs nothing.

Before Anyone Asks, No, This Is Not an Overlay

I can already see the comment. Someone is going to read this post, see forty-seven AI agents and the word accessibility in the same sentence, and think: great, another magic fix. Another overlay. Another tool that claims to solve accessibility so developers do not have to think about it.
No. Absolutely not. If you have read my writing before, you know how I feel about overlays. One of them literally broke my rent portal so badly that I could not pay rent until the landlord removed it. I have written an entire post about why overlays are harmful. I am not about to build one.
Let me be crystal clear about what Accessibility Agents is and what it is not.
This is a developer tool. It runs inside your code editor while you are writing code. It helps the AI write more accessible code from the start. That is it. It does not touch your website. It does not add a widget. It does not inject JavaScript into your pages. It does not promise compliance. There is no toolbar. There is no badge. There is no fee.
And here is the part I really need you to hear. This does not replace testing with real assistive technology. It does not replace VoiceOver. It does not replace NVDA. It does not replace JAWS. It does not replace a human being navigating your site with a keyboard and a screen reader and telling you what is broken.
What it does is raise the floor. Code that comes out of an AI tool with these agents active is going to be more accessible than code that comes out without them. Labels will be there. Focus trapping will be there. ARIA roles will make sense instead of being scattered like confetti. Contrast ratios will be checked before you ship, not after someone files a complaint.
That is not a magic fix. That is a better starting point. You still need to test. You still need real users. You still need to care. But at least you are not starting from zero every single time.
If anyone tries to sell you a tool that replaces accessibility testing, run. This is not that tool. This is the tool that makes the code better before testing even begins.

It Moved

The project does not live under my personal GitHub account anymore. It is at the Community Access organization now.
That was deliberate. This is not my project. It is not Jeff’s project. It is a community project. The more perspectives and lived experiences that go into these agents, the better they serve the people who need them.

Thirty Pull Requests in Five Days

I keep coming back to this number because it tells the story better than anything else I can say.
Thirty pull requests merged in five days. That means thirty separate changes were proposed, reviewed, and added to the project. Three hundred and sixty files changed. Seventy-three thousand lines of code added. Thirty-four security vulnerabilities identified and resolved. Path traversal prevention. Injection protection. ZIP bomb limits. Input validation at every call site.
This was not a casual weekend project. This was a sprint. Jeff and I were building in parallel, reviewing each other’s code, catching issues, pushing fixes. The velocity was unlike anything I have experienced on an open source project.
And it happened because people who need accessible software decided to stop waiting for someone else to build it.

Why This Matters

AI coding tools generate code at a speed and scale that humans never could. If that code is inaccessible by default, the problem is not getting smaller. It is getting bigger. Fast.
Ninety-five point nine percent of the top one million websites already have detectable accessibility failures. That number has barely moved in years. AI tools risk making it worse by automating the same mistakes at a scale no human team could match.
I am a screen reader user. When AI generates a modal without focus trapping, I am the person who gets stuck. When it skips live regions on search results, I am the person who hears nothing. When it uses a div with an onClick instead of a button, I am the person who cannot activate it with my keyboard.
But here is what I have learned over the past five days. I am not the only one who feels this way. Jeff feels it. The people who starred the repo and opened issues feel it. This is not one person’s frustration. It is a shared experience across an entire community that has been dealing with inaccessible software for decades.
That is why this is not just me. That is why it cannot be just me. One person’s agents catch one person’s blind spots. A community’s agents catch the patterns that none of us would find alone.

Version 2.0

On Tuesday, Jeff and I got on a call and decided it was time. We were going to release version 2.0.
Five days earlier I had six agents and a personal repo. Now we had forty-seven agents, three platforms, a GitHub organization, a website, and a community. It was not a preview anymore. It was a release.
We published the official announcement yesterday. You can read the full press release on the Community Access website:

https://community-access.github.io/news.html#post/accessibility-agents-v2-launch

I am sharing it here because this community has followed this journey from the beginning. You read the preview post on Friday. You saw the Swift agent team launch. You have been here for the frustration and the building and the breakthroughs. You deserve to see how it landed.
Forty-seven agents. Three platforms. One command to install. Zero cost. That is the headline. But the real story is that a community built this in five days because the tools we depend on every day were not building it for us.

Be Part of This

So now I am promoting it. And I am hoping you will try it out.
I want to make this as easy as possible. You do not need to be a developer to help. You do not need to write code. You do not need to know what ARIA stands for. If you care about accessible software, there is something you can do right now.
Talk about it. Share the project with someone who builds software. Post about it. Mention it in a conversation. The biggest thing holding accessibility back is that not enough people know it is a problem. Every time someone new hears about this project, that changes a little.
Try it. Install it with one command. Use it on your next project. See what it catches. See what it misses.
If you find a bug, file it. Go to the GitHub repo, open an issue, and describe what happened. What you expected. What you got instead. That is it. A good bug report is one of the most valuable contributions anyone can make. It does not take expertise. It takes honesty.
If you want to contribute code, the agents are plain markdown files. You do not need special tooling. You do not need permission. Fork it, make a change, open a pull request. Jeff did exactly that on Saturday morning and look where we are now.

Website: https://community-access.github.io/
GitHub: https://github.com/Community-Access/accessibility-agents

Thank You

To Jeff, for picking this up on Saturday morning and not putting it down. For removing the hooks when I was still trying to fix them. For writing forty-three commits in five days. For caring about this as much as I do.
To every contributor who showed up, opened a PR, filed an issue, or starred the repo. You turned a frustrated Friday night into something real.
And to everyone reading this. If you build software, you have the power to make it accessible. These agents are one way to start. But they are not the finish line. They are the starting block.
This is how it starts. Not with a company. Not with funding. With people who got tired of fighting the same fight every day and decided to build something that fights back.
That is not just me. That is all of us.





_______________________________________________

NFBCS mailing list

NFBCS at nfbnet.org<mailto:NFBCS at nfbnet.org>

http://nfbnet.org/mailman/listinfo/nfbcs_nfbnet.org

To unsubscribe, change your list options or get your account info for NFBCS:

http://nfbnet.org/mailman/options/nfbcs_nfbnet.org/tyler%40tysdomain.com
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://nfbnet.org/pipermail/nfbcs_nfbnet.org/attachments/20260225/09d487fd/attachment.htm>