Grego Security OS
The same engine in a self-service continuous layer, with persistent memory carrying project context between runs.
AI Security Harness
for Complex Systems
Find critical vulnerabilities that tests, scanners, and auditors miss.
Grego’s AI security harness coordinates thousands of specialized agents to test hypotheses in parallel, from local logic to cross-component interactions and shared dependencies. Promising paths are challenged, refined, and consolidated into high-confidence findings.
- in bounties
- $900k+
- AI bounty record
- $250k
- of value protected
- $189.2M
Helping secure
The Grego Harness
A Grego run can start from a full system, repo, component, or diff. The code in scope defines what receives explicit coverage, not where an investigation must stop. Thousands of agents investigate different functions, call paths, and potential failure modes in parallel.
Explicit scope coverage
Every scoped function receives explicit coverage. Multiple agents investigate each one, pursuing hypotheses along different paths through the code rather than concentrating on obvious hotspots.
Follows the system
Agents do not stop at scope boundaries when behavior depends on code elsewhere. They follow paths into integrations and dependencies, looking for failures that emerge across those boundaries.
Language and stack agnostic
Supports any tech stack or language, from Solidity to DAML. Contracts to frontends and APIs are investigated as one system through code and its interactions across languages, repos, and runtimes.
One harness, two modes
Where Grego Fits
Grego fits around your security engagements like audits or competitions. Each run targets an exact commit and is tailored with your team around the architecture, invariants, and trust boundaries. Covers a full codebase, critical component, integration, or release, once or on an agreed cadence.
Before an audit
Find common vulnerability classes early. Your audit partners receive a clean base to review.
Alongside an audit
Review the same commit in parallel. Agents extend coverage beyond one team’s language and specialties.
After an audit
Test residual risk across neglected surfaces, disputed assumptions, cross-component interactions, and dependencies.
Between audits
Review releases and deltas as code changes. The diff is the starting point and agents follow its effects into wider code and dependencies.
Grego Audits
A managed review powered by the Grego AI harness for a full codebase, critical component, integration, or release. Best suited to a new system, high-risk component, critical release, integration, or residual-risk review.
Book a scoping callHow It Works
The Grego AI harness drives each review from initial codebase context through thousands of parallel investigations, evidence challenge, and final report assembly.
Map the scope
We map and scope your codebase.
- Indexes the codebase
- Traces dependencies and function call paths
- Organizes scope into domains and components
- Ranks domains and components by criticality
Tailor the run
We produce a scope report and gather your context.
- Mapped domains, components, and their failure modes
- Tailored attack-vector selection, analysis depth, and iterations
- Full scope or selected components
- Scope and budget finalized before the run starts
Run the investigation
We execute the tailored run across the agreed scope.
- Thousands of agents iterate on hypotheses
- Promising paths expand into adjacent code and assumptions
- Candidate findings are challenged against evidence
- Regression tests are built where needed
Deliver the report
You receive a first-class report on the platform.
- Clean, crisp walkthrough with step-by-step attack sequence
- Likelihood, impact, severity, and supporting evidence
- Dollar estimate of economic impact where quantifiable
- Your team reviews findings and remediation in the platform
Grego Platform
Each review produces a Grego report, a low-noise technical deliverable with findings you can act on. The harness favors signal over finding volume, challenges the strongest candidates, and follows promising paths further to uncover related vulnerabilities.
phi/phi-contracts
today2 of 4findings2 Critical findings1 High finding1 Medium finding
GitHub128 files 12,300 LOC2465e04
- CriticalResolved
CreatorRoyaltiesControl _updateRoyalties Allows royaltyAmount Exceeding Sale Price
src/abstract/CreatorRoyaltiesControl.sol :: getRoyalties
The `CreatorRoyaltiesControl._updateRoyalties` function stores `royaltyBPS` without validating it against `ROYALTY_BPS_TO_PERCENT` (10,000).
- CriticalOpen
PhiFactory _validateAndUpdateClaimState Missing PerMinter Replay Protection
src/abstract/Claimable.sol :: signatureClaim
The `_validateAndUpdateClaimState` function in `PhiFactory` writes `artMinted[artId_][minter_] = true` unconditionally without ever reading it as a precondition.
- HighConfirmed
CuratorRewardsDistributor distribute Unbounded Iteration Locks Curator Funds
src/abstract/RewardControl.sol :: depositBatch
The `CuratorRewardsDistributor.distribute()` function iterates over an unbounded `EnumerableMap` in `Cred.sol` whose entries are never removed, processing every
- MediumAccepted risk
PhiNFT1155 safeBatchTransferFrom Bypasses whenNotPaused Guard
src/art/PhiNFT1155.sol :: safeBatchTransferFrom
The `safeBatchTransferFrom` and `safeTransferFrom` functions in `PhiNFT1155.sol` lack the `whenNotPaused` lifecycle guard modifier, allowing any token holder to
Illustrative example. Representative of the engine's output.
Private code stays private
You connect only the repositories you want Grego to review and can disconnect them through the platform at any time. We sign NDAs and do not use customer code, findings, or project context to train models.
Security
Researchers
The Grego AI harness drives discovery across the full scope, coordinating thousands of parallel investigations and producing the evidence behind each finding. Grego’s security researchers bring public records spanning protocol engineering, audit competitions, and bounty work across smart contracts and distributed systems.
1 / 6
Public Findings
These findings came from public codebases and were accepted through bounty or responsible-disclosure channels. Each entry names the failure path, its limits, and the public change that followed.
Gnosis Safe Drain via Spoofed Question Rendering
A permissionless caller could inject the Reality.eth field delimiter into a Zodiac proposal ID. The interface displayed a legitimate transaction hash while the module committed to attacker-controlled calls.
CriticalOnce voters approved the legitimate-looking question, the hidden calls could execute with full Safe authority. One affected deployment was the GnosisDAO treasury, which held about $65 million at disclosure.
Yearn yYB: Unbacked double mint and liquidity drain
A new operator recorded the locked balance when deployed but did not resync when activated. An attacker could grow the lock under the old operator, trigger an NFT callback after rotation, and mint the full stale delta again as unbacked yYB.
CriticalThe attacker could exchange unbacked yYB for YB up to available pool reserves. Exploitation required an operator rotation, a transferable veNFT, and the first callback after activation.
EIP-8024 Reentrancy
With EIP-8024 enabled, the DUPN, SWAPN, and EXCHANGE handlers advanced the program counter by two before the interpreter advanced it again. Bytecode using them skipped the following opcode, allowing exact layouts to bypass a state update and reach an external call first.
CriticalLow likelihood. EIP-8024 was experimental, feature-gated, and not enabled on Ethereum mainnet.
Gnosis Guild Zodiac Roles Modifier: Crafted MultiSend Payload Permission Bypass
The MultiSend unwrapper bounded inner entries against padded outer calldata instead of the actual inner payload. A crafted final entry could make the permission checker approve attacker-controlled trailing bytes while MultiSend executed zeroes in their place.
CriticalPermission-boundary failure. Exploitation required an already assigned role and affected only the final 1 to 31 trailing bytes of the last transaction.
Limited accessSecurity That Compounds
Security That Compounds
with Every Run
Grego Security OS extends the engine behind Grego Audits into a self-service continuous layer. Persistent memory carries your architecture, feedback, findings, and tested hypotheses from one run to the next. Fully self-serve and autonomous.
Join waitlistFrequently asked questions
Does Grego replace a traditional audit?
Grego can lead a security review or run before, alongside, or after another audit. Whether it replaces a traditional audit depends on the job and any external requirement for a specific provider.
Why review code that has already passed audits or competitions?
Previous reviews are tied to a particular scope, commit, timeline, and set of hypotheses. Grego can target changed code, neglected surfaces, cross-component interactions, dependencies, or residual risk left by earlier work.
Why use Grego instead of internal security skills?
Internal security skills can be effective, especially for routine changes and known project risks. Grego adds an AI security harness that maps the scope, coordinates parallel investigations across the system, and returns evidence-backed findings in an accountable report without requiring your team to build and maintain the workflow.
How does Grego compare with lower-cost scanners?
Lower-cost scanners are useful for fast, routine checks. Grego maps an agreed scope, uses your architecture and invariants to coordinate thousands of specialized agents, and delivers findings that have been triaged and validated before they reach your team.
Which languages and systems are supported?
Grego is designed to be language- and stack-agnostic. Current experience spans Solidity, Rust, Go, C, CosmWasm, Move, and TypeScript; fit for each codebase is confirmed during scoping, and Solidity is strongest today.
What parts of a system can Grego review?
Grego can review complex systems across frontends, backends, APIs, SDKs, distributed services, blockchain and DLT infrastructure, smart contracts, deployment code, and integrations when their source is in scope. It follows relevant interactions between these parts, but live configuration and deployed state are not implied by a source-code review.
Is Grego a source-code review or a penetration test?
Grego Audits are white-box source-code reviews, not outside-in penetration tests. They use repository access and project context to investigate code and relevant dependencies.
How are scope and price determined?
You share a repository, component, or diff at an exact commit. We map its components, call paths, dependencies, and SLOC, then review the breakdown with your team and quote the agreed scope. If the code or scope changes, we update both.
How long does a review take?
Timing depends on scope, system complexity, available context, and release deadline. We confirm the schedule after mapping the code and can plan the review before, alongside, or after another engagement.
What remediation support is included?
Each finding includes remediation guidance, and your team can review proposed fixes with the lead researcher. We can retest the original failure path against a remediation commit, but targeted verification does not reassess the whole system.
What repository access is required, and how is private code handled?
You authorize only the repositories included in the review. Private repositories are accessed through short-lived GitHub App credentials limited to read-only contents access for the selected repository. Code is processed by Grego AI's authorized scanning infrastructure, researchers, and service providers solely to deliver the review. Customer code and reports are not used to train general-purpose models or shared with other customers.
Where can I read and share Grego AI's public findings?
Published bounty findings and responsible disclosures are available in the Public Reports directory. Each Grego AI report page preserves the failure path, impact, original public disclosure, and remediation evidence at a stable link that can be shared directly.