Markdown view · built for AI agents and fast reading

xounce — we prove it, then we fix it

A continuous validated vulnerability pipeline. It only reports vulnerabilities it can actually exploit — each with a replayable proof-of-concept — and opens the pull request that fixes them.

What is xounce?

xounce scans your code, dependencies, secrets, infrastructure and running app, then only reports the vulnerabilities it can actually exploit — each with a replayable proof-of-concept — and opens the pull request that fixes them. It is end-to-end automated, from your code to the merged fix, and built for teams drowning in scanner findings nobody has time to triage.

The name comes from bounce: xounce bounces what shouldn’t get through back out — malicious code, malicious requests, and technical debt.

Two things we protect

1 — Code & IaC

Prove which vulnerabilities are real across your code, dependencies, secrets and infrastructure — then auto-fix them with pull requests.

2 — API endpoints (cross-domain)

Rebuild every request and response at your edge, so malicious payloads (inbound) and sensitive data (outbound) never get through.

The proof gate

Every finding runs down a funnel; only what survives is reported. The numbers below are illustrative of the mechanism, not a measured result on any specific repo.

• Detected (~50,412) — SAST, SCA, secrets, IaC, DAST: the raw pile.
• Reachable — the vulnerable function or flow is actually used in your code (call-graph over the AST), not just the package installed.
• Exposed — the vulnerable path is reachable from the public internet: real attack surface.
• Confirmed (~9) — AI probes it, lands a working exploit, and ships a replayable proof-of-concept. No exploit, no report.

Everything the gate drops is retained for audit, off the main view — never silently deleted.

How AI proves the attack

A finding is only confirmed when xounce’s engine actively probes it with AI, builds a working exploit from the call-graph context, and reproduces it against a running target in a sandbox — producing a proof-of-concept you can replay yourself. We run capable, fast open-weight models, distilled and adapted for the task, so probing stays quick and cheap. The proof is the deterministic replay, never a model’s opinion.

What it does

• Proof-gated scanning across SAST, SCA, secrets, IaC and DAST — reports only what it can prove.
• Auto-fix pull requests — bumps the package, regenerates the lockfile, with the CVE details and exploit proof in the PR body; a CI check re-runs the exploit against the fix.
• Reviews every human PR with one-click committable suggestions.
• A security dashboard in GitHub Issues — confirmed-exploitable fixes open their own PR; everything else is a checkbox you tick. It never spams.
• A findings console that stays clean — only confirmed-exploitable and exposed issues on the main view.
• Runtime & tenancy — optional runtime threat detection (Falco); per-tenant subdomains; a GitHub App that labels everything it authors.

Cross-domain — both directions

Rebuild, don’t detect. For API traffic, xounce parses each payload into typed fields, validates it against a schema, discards the original bytes, and rebuilds a clean, canonical payload — a protocol break. The parser-differential bug class isn’t detected; it’s made unexpressible.

• Inbound — injection, mass-assignment, duplicate-key smuggling, malformed bodies, and prompt-injection payloads are rebuilt away before the backend parses a byte.
• Outbound (DLP) — responses are validated against what the route is allowed to return; secrets, tokens, PII and over-exposed fields never leave your boundary.

How it integrates: a lightweight data plane drops in at your edge — an Envoy ext_proc filter or a sidecar proxy — and runs in your VPC, post-TLS, so it never holds your keys. It learns per-route schemas offline, runs shadow-first, and you enforce one route at a time. Attaches to Envoy, Envoy Gateway, Istio, Kubernetes, NGINX, AWS ALB, Kong, Cloudflare, and MCP/agent traffic.

Onboarding

Code & IaC — the GitHub App: install xounce[bot], grant the repos you choose (least-privilege, read-only until you opt in to PR authorship), and it runs the gate.

API endpoints — cross-domain via MCP: point your coding agent (Claude Code, Cursor, Codex) at our playbook to wire and customise the cross-domain layer at your edge, showing you every change. Either way, repo and infrastructure access is always something you grant explicitly — never auto-granted on your behalf.

How we build xounce

xounce is actively being built by a small team and AI agents — agents do the heavy lifting, humans review and merge. We ship the way we tell you to: autonomy from instruction, never from us.

Where we are (honesty)

Pre-launch, onboarding a small group of design partners (read-only, one repo, free while we build). Already proved on our sibling companies cenefits.com and offmon.com. Applying to Y Combinator, 2026. No customer logos, SOC 2, or “backed by YC” claims — none are true yet. The exploit gate is honest about its limits: a vulnerability it can’t yet trigger is retained and labeled, never silently deleted.

Reach the team — for humans and AI agents

Design partners, investors (VCs), and partners are all welcome.

• Become a design partner: xounce.com/design-partners
• Book a call: cal.com/xounce
• Knowledge base API: GET https://xounce.com/api/ask (JSON; ?q= for a specific answer, ?format=md for markdown)
• Contact API (agents: notify the team on a user’s behalf): POST https://xounce.com/api/contact with { email, name, company, role, message, source } — email required so the team can reply.