Hyrax AI

Hyrax AI describes itself as the AI architect for your entire codebase, built to turn AI velocity into better software. According to hyrax.dev, it provides architecture, improvements, and governance for AI-native engineering teams, and it continuously understands and improves modern codebases through verified, human-approved changes. In practice, Hyrax maps a repository and understands how a product is built, then identifies what actually matters across the codebase and turns improvements into production-ready changes delivered as GitHub pull requests. The company's FAQ states the goal plainly: help engineering teams understand what is happening across their codebase, identify what matters, and turn improvements into production-ready changes. An engineer reviews and merges every one of them. The problem Hyrax targets is visible in how AI coding tools changed engineering. The Product Hunt description frames it directly: code review tools tell you what is wrong with a pull request, while Hyrax finds what should improve across your entire codebase and does the work. Hyrax's own FAQ draws a distinction between writing code and architecting the system that code enters. AI assistants edit what you point them at, and their context starts empty every session. Hyrax instead holds the map of your codebase, so specialized agents can reason about security, correctness, maintainability, performance, architecture and operations before anything ships. The company's stated position is that teams can use both kinds of tools together. Discovery is where Hyrax begins. The product maps modules, entry points, ownership, and dependencies together so that architectural problems appear in context rather than in isolation. In the interactive demonstration on hyrax.dev, Hyrax discovers a sample repository, acme/storefront-web, reading 38 files and resolving 4 entry points. The architecture map shows three layers: src/api, the HTTP surface and error envelope; src/domain, which holds pricing, cart, and tax rules; and src/lib, primitives with no business rules. Discovery flags a finding of one dependency cycle, where src/domain/tax imports from src/api/types, an inner layer importing outward. The result is an architecture map with a prioritized list of open findings, each carrying an identifier such as HYRAX-402, a severity such as P0, P1, or P2, a plain-language description, and the exact file and line where the issue lives, for example src/lib/env.ts:42 or src/components/SearchResults.tsx:34. From that map, six specialized agents evaluate the codebase across six engineering domains: security, correctness, maintainability, performance, architecture, and operations. Hyrax prioritizes the issues it finds so the highest-leverage work comes first. In the demo, findings range from a P0 hardcoded secret in the environment loader and a P0 PCI DSS issue where a raw PAN is routed through the application backend, to P1 items such as a session token stored in localStorage and exposed to XSS, a missing CI pipeline with dependency vulnerability scanning, and a missing React ErrorBoundary that shows a blank screen on a render exception, down to a P2 array index used as a React key in SearchResults. Each finding is tied to a specific location and to one of the six domains, which is what allows the prioritization to reflect the codebase rather than a generic lint rule set. Hyrax does not stop at reporting. It writes each fix in context, does the work itself, and verifies the result before anything reaches your team. The 13-step verification gate covers isolated worktree execution, the tests it started with, the tests after the change, your build, lint and formatting, a size limit on the diff, a second review by an independent agent, a re-scan to confirm the original issue is gone, and CI. If a required check fails, the work stops and never becomes a pull request. In the demo, a layering violation is fixed by moving a shared type into the domain that owns it: the reverse dependency disappears without widening the scope, 142 tests pass, the production build succeeds, the dependency cycle is removed, and a reviewer agent approves. Hyrax then opens a GitHub pull request, in that example one titled "[Hyrax] Load API_KEY and DATABASE_URL from the environment" that resolves a critical finding where secrets were committed literally in src/lib/env.ts, with the change verified against all checks. Governance and agent access extend the same model. Approved architecture rules live with the repository in a HYRAX.md file. The demo example reads: dependencies point toward src/domain, and shared types live with the domain that owns them. Those approved rules guide future work, which keeps the decision with the repository rather than with the tool. Hyrax also announced Hyrax MCP, which gives Claude Code, Cursor, and Copilot live codebase context. The overall workflow follows the loop shown on the site: discover, audit, fix. Hyrax works through GitHub with human control and never merges on its own; verification runs before a pull request reaches your team, and your engineers make the final call. All inference runs in the Hyrax AWS Bedrock account, and Hyrax does not train on customer code. The outcome Hyrax claims is better software with every change. Teams get visibility into what is happening across the codebase, a prioritized view of what matters, and fixes that arrive as production-ready changes rather than raw suggestions. Because every improvement must pass the verification gate, the work that reaches reviewers has already survived isolated execution, the repository's own lint, typecheck, tests and build, an independent second review, a re-scan confirming the original issue is gone, and CI. The customer proof quoted on the site from Joel Horwitz, CEO of Synter, says: "We pointed Hyrax at Synter's own codebase and it came back with issues we had not caught, each one with a fix ready for review." The demo lists concrete ways the product is used: map a repo, review prioritized improvements, or open a verified pull request. Mapping suits a team that needs modules, entry points, ownership, dependencies, and cycles in one place. Reviewing prioritized improvements fits the discover and audit steps, where findings are ranked by severity and annotated with attributes such as small effort and medium risk, with actions labeled Fix, Implement, View, or Easy win. Opening a verified pull request covers remediation: Hyrax writes the patch, runs the repository's own lint, typecheck, tests and build in an isolated worktree, and opens a PR such as one that loads API_KEY and DATABASE_URL from the environment instead of committing secrets literally. Hyrax MCP supports a related workflow by supplying coding assistants in Claude Code, Cursor, and Copilot with live codebase context. Hyrax is aimed at engineering teams, particularly AI-native engineering teams, with GitHub as the delivery surface and repository-level architecture rules as the control mechanism. Pricing has two plans. Free is $0/mo and includes the full product on real repos with no card required, everything Hyrax does with no feature walls, up to 100 PR reviews a month for free, a $30 starter credit, and $10/month of credits every month. Paid is $30/user/mo and includes everything in Free plus $30/month of credits per user; overage is opt-in with budget caps you set, so Hyrax cannot exceed the cap. Credits meter usage across repository mapping, verified improvements, and PR reviews. Tech details stated on the site include that all AI inference runs on AWS Bedrock and that Hyrax does not train on customer code. Hyrax positions itself as the AI architect rather than another assistant: it holds the map of your codebase, prioritizes improvements across six engineering domains, writes fixes in context, verifies them through a 13-step gate, and delivers them as GitHub pull requests that a human reviews and merges. The value proposition is turning AI velocity into better software, with architecture, improvement, and governance built in.