I focus on finding concrete, reproducible bugs in open-source SDKs and developer infrastructure. The work runs through an AI-orchestrated workflow — deep code reading, adversarial verification, and structured disclosure — gated by my approval at decision points. Methodology is detailed in the AI Disclosure section below.

Active in ecosystems across DeFi, AI agents, Web3 bridges, fintech SDKs, and developer tooling. The preference is for execution over speculation, structured disclosure over hype, and durable signal over volume.

My work spans security research, SDK auditing, and open-source contribution across multiple ecosystems.

Focus areas:

• SDK code-correctness audits (TypeScript, Python, Rust, Solidity)
• Async race conditions and lifecycle bugs
• Type-binding drift between SDK declarations and runtime behavior
• OpenAPI generator artifacts and schema validation gaps
• Decimal/precision handling in financial systems
• Responsible disclosure via HackerOne and GitHub Security Advisories

The workflow runs long structured audit sweeps with adversarial verification stages — primitive check against repo code, duplicate search, PoC execution with verbatim output capture, and scrub for severity inflation or meta-instruction leaks. Findings that fail any gate are dropped or deferred. Approval gates are mine; drafts and verification are AI-orchestrated.

• SDK code-correctness in TypeScript / Python / Rust / Solidity
• Async race conditions and lifecycle bugs
• Type-binding drift between SDK declarations and runtime behavior
• OpenAPI generator artifacts and schema validation gaps
• Decimal/precision handling in financial systems
• Open-redirect, SSRF, and timing-oracle patterns
• Auth-callback routing failures and token-lifecycle violations
• GitHub Security Advisory (GHSA) coordinated disclosure
• HackerOne report drafting (CVSS 4.0, CWE classification)

I audit production-runtime SDKs for concrete code-correctness bugs that affect SDK consumers and downstream applications. The goal is always a 1-3 line fix and a passing test, not a theoretical hazard.

Merged PRs (commits authored by me):

• initia-labs/initia.js#168 — Cosmos denom regex spec alignment

Issues I filed that maintainers fixed (commits authored by maintainers):

• vercel/turborepo#12975 → fix PR #12976 by @anthonyshew (auth HTTP timeouts)
• plaid/react-native-plaid-link-sdk#905 + #906 → fixed in v12.8.2 by @dtroupe-plaid (LinkAccountSubtypeLoan + SIPP typo)
• open-webui/open-webui#25464 + #25465 → fix PRs #25479 + #25478 by @Classic298 (terminal proxy hang + interval leak)

Open PRs awaiting review:

• drizzle-team/drizzle-orm#5829 — PgNumericBigInt scale handling + regression tests
• drizzle-team/drizzle-orm#5830 — singlestore session iterator cleanup
• burnt-labs/xion.js#378 — abstraxion-core grant comparison
• base/account-sdk#327 + #328 — spend-permission + sub-account error propagation
• across-protocol/json-constants#5, #6, #7 — duplicate key removal, npm provenance, network categorization
• 0xPolygon/lxly.js#65 — optional option guard
• nuxt/nuxt#35213 — forwardedPrefetchEntries normalize

Active issue sprints:

• Polymarket SDK ecosystem (py-sdk, ts-sdk, clob-client-v2)
• Across-protocol (toolkit, relayer, json-constants, sdk)
• Cloudflare OSS (workers-sdk, agents, sandbox-sdk) — 6 GHSAs in triage

I file responsibly via the channel that fits the finding class — HackerOne for in-scope programs, GitHub Security Advisory for direct-to-maintainer coordination, public GitHub Issues for pure code-quality bugs.

Disclosure principles:

• Verify every claim against the actual repo code before submission (workflow stage 1)
• Calibrate severity to the actual impact path (CVSS 4.0 with reasoned vector); downgrade MED→LOW when the bug class is default-config hardening or documented by-design framing
• Submit one finding per report, no padding
• Include suggested fix and concrete reproduction steps

When a bug class appears once, it usually appears across the ecosystem. The workflow systematically hunts the same pattern across related repositories to surface cross-project occurrences and structural causes.

Recent pattern hunts:

• Missing AbortSignal.timeout() on critical-path fetches (vercel/turborepo, vercel/workflow, vercel/flags)
• Map/Set leak on consumer unsubscribe (trpc, drizzle-orm × 2, open-webui)
• Type signature drift on optional fields (Plaid React Native, hono jwt, drizzle PgNumeric)

Every finding passes through workflow verification stages before submission: primitive verification against actual repo code, duplicate search in the target repo, PoC execution with verbatim output capture, and adversarial scrub for severity inflation or meta-instruction leaks.

The pipeline prioritizes signal quality over raw output. Findings that fail any gate are dropped or deferred. What a project receives is filtered through this verification, not unreviewed AI output.

Right now, I'm especially focused on:

• Coordinated GHSA disclosure on cross-chain bridge SDKs
• Cloudflare OSS production-runtime audit pass
• Plaid React Native SDK lifecycle and type-binding review
• Building a multi-program signal-pool strategy across HackerOne, GHSA, and direct GitHub

I use AI-assisted tooling (Claude Code, GPT-4/5, OpenAI Codex when available) as the primary engine across my workflow:

• At scale: initial code reading, dependency mapping, pattern hunting across large repos
• At draft time: issue bodies, fix recommendations, PoC reproducers, test plans
• At verify time: adversarial review, dupe checks, primitive verification against actual repo code
• At cleanup time: meta-instruction scrubbing, severity recalibration, RFC compliance checks
• At push time: workflow-orchestrated gh CLI filings and signed commits to PR branches

What this means in practice:

• Issue bodies, PR commits, severity calibration, and final wording are workflow-authored. My role is approval gates ("file this batch", "drop this", "concede to this maintainer") rather than line-by-line authorship.
• Multiple verification stages run before any submission: primitive check against the actual repo code, dupe search in target repo, PoC execution with verbatim output capture, adversarial scrub for meta-instruction leaks and severity inflation. Findings that fail any gate are dropped or deferred.
• "Tested locally" in a comment means the actual app or library was run against the actual scenario. Synthetic reproducers are explicitly framed as such ("verified via standalone reproducer", "code-walked", "structural review").
• Commits are signed with my SSH key (ED25519 SHA256:CWX60WPoOQcianliIELliGtEftFs9vEnkLmywphAUP8). Content is workflow-authored under my approval; signing attests to my responsibility for it being pushed, not to manual line-by-line authorship.
• I will not dispute Informative or wontfix closes — when a maintainer's reading is sound, I concede.
• I will not re-engage after a maintainer warning — silence is the right response.

If a maintainer prefers no AI-assisted disclosures on their project, please say so on any of my reports and I will respect it. I would rather lose a finding than misrepresent how it was produced.

• HackerOne: hackerone.com/nexory
• Email: open to coordinated disclosure on private security advisories

If you maintain an SDK and want a focused audit pass, reach out — the workflow runs in structured sprints with confirmation gates and a documented opt-out for AI-assisted reports.

If something I've reported helped your project or saved your users from a bug class, consider sponsoring future research:

Every contribution funds more research time spent reading code and filing high-signal disclosures.

• Location: Europe
• Background: Security research, SDK audit, responsible disclosure
• Work Style: AI-orchestrated workflows with my approval gates at decision points; long structured sweeps; adversarial verification stages
• Interests: SDK code-correctness, cross-chain bridges, AI agent security, fintech integrity
• Approach: Read code thoroughly via workflow, verify via multi-stage gates, disclose responsibly via the appropriate channel
• Mindset: Signal quality over filing volume; durable maintainer relationships over individual commit credit; honest framing over marketing rhetoric