Documentation

How Alphaea works

A plain-language tour of the platform — what each part does, how a scan flows from target to proof-backed finding, and why it stays inexpensive on your own AI. Enough for a tester to trust it, an investor to grasp it, and an engineer to see the shape of it — without exposing the proprietary internals.

Start here

What Alphaea is

Alphaea is one security platform that covers the whole surface of a modern application: its source code, its dependencies and secrets, its infrastructure-as-code, the live web app, the network around it, and the cloud accounts it runs in. Instead of stitching together six separate tools, a tester drives all of it from one console.

The part that makes it different: Alphaea supplies the logic — how to look, what to try, how to prove it — but the thinking is done by whatever AI model you connect. Bring Kimi, Claude, Llama, OpenAI, DeepSeek, or a fully local model. Alphaea runs a deterministic engine first so most of the work costs no tokens at all, and only hands your model the small, structured questions that actually need reasoning.

Three promises hold across the whole platform: your AI does the reasoning, nothing leaves your boundary (on self-hosted / hybrid tiers), and every reported vulnerability ships a reproducible proof.

The big picture

How it fits together

At a glance: your targets go into the console; an orchestrator checks them against a signed scope and routes each one to the right engine; deterministic checks run first, your AI reasons over what is left, and the results become reports, framework coverage, a CI/CD verdict, and learning.

YOUR BOUNDARY — CODE · TRAFFIC · FINDINGS NEVER LEAVE Your targets Source code Dependencies IaC / configs Live web apps Networks Cloud accounts Console UI pick scope, run, review, report Orchestrator + signed scope gate (fail-closed) Engines SAST · SCA · Secrets IaC / Config DAST (web) Network Cloud posture (CSPM) Deterministic first (rules, parsers — no tokens) Then your AI (reasoning on structured input) Your AI (BYO) Kimi · Claude · Llama OpenAI · DeepSeek · local the thinking is done here Findings become… Reports (proof-backed) Framework coverage CI/CD gate · Learning
Everything inside the dashed boundary stays with you. Your AI is called for reasoning; your code, traffic and findings are not shipped out.

Dynamic testing

The validated scan pipeline

When Alphaea tests a live web application it runs a chain of stages. Each stage has one job, and the second-to-last one is the reason the reports are trustworthy: if an attempt can't be proven, it never becomes a finding.

Recon Crawl Planner Exploit Judge Reporter no proof-of-exploit → discarded Every finding that reaches the report carries a reproducible proof. That gate is what keeps false positives out.
Recon and crawl gather the surface; the planner (your AI) proposes hypotheses; exploit attempts them within the signed scope; the judge demands proof; the reporter writes it up.
1

Recon

Maps the reachable surface and where user input is reflected — the raw material every later stage reasons about.

2

Crawl

Walks the application to discover every page, parameter and form within the crawl limits you set.

3

Planner

Your connected model turns the surface into concrete, testable hypotheses about likely weaknesses — guided by Alphaea's instruction sets.

4

Exploit

Safely attempts each hypothesis using scope-gated techniques. Nothing outside the signed scope is ever touched.

5

Judge

Every attempt is checked for a real, reproducible effect. No proof-of-exploit, no finding — this is what keeps false positives out.

6

Reporter

Turns each validated result into a developer-ready finding: severity, evidence, remediation and framework mapping.

The toolbox

The engines, one by one

Each engine is deliberately simple to reason about: what it looks at, what it gives back, and whether it needs your AI or runs purely on deterministic rules.

DAST

Live Web Application Testing

your AI + validated proof gate

Explores a running application the way an attacker would — mapping pages, parameters and forms, forming hypotheses about weak points, and safely attempting them inside an authorized scope. It reports a vulnerability only when it captures a working, replayable proof.

Input: a target URL and scope. Output: validated findings (XSS, SQLi, injection, path traversal, open redirect and more), each with a reproducible proof and remediation.

SAST

AI Code Review

deterministic + your AI

On scan-start a deterministic pass lints the code, builds a cross-file reachability view and flags dead code — with zero tokens. Then your connected model reviews the reachable code for injection, unsafe calls, broken auth/authz, weak crypto and unsafe deserialization, and drafts a hardened patch for your approval.

Input: a connected repository or uploaded code. Output: prioritized code findings + optional one-click hardened patch on a branch.

SCA

Dependencies & Secrets

deterministic · no tokens

Parses npm, PyPI, Maven, Go and Ruby manifests against the open OSV vulnerability feed to surface vulnerable and outdated components, and sweeps the whole tree for committed keys, tokens and private keys.

Input: dependency manifests + source tree. Output: vulnerable-component findings (with fixed-in versions) and exposed-secret findings.

IaC / Config

Infrastructure as Code

rules + your AI

Checks Dockerfiles, Kubernetes, Terraform and compose for insecure defaults — root containers, world-open ingress, unencrypted storage, public data stores. Uploaded Terraform / CloudFormation / policy files are checked pre-deploy against the same posture rules; with an AI connected it can also propose a hardened version.

Input: config files or a connected repo. Output: misconfiguration findings mapped to CIS, before anything is deployed.

Cloud (CSPM)

Cloud Posture

deterministic · no tokens

Audits live posture across AWS, Azure and GCP against CIS benchmarks — read-only — covering public exposure, encryption, IAM over-privilege, logging and MFA. No SDK? Bring an exported inventory JSON and the same checks run offline.

Input: read-only cloud credentials or an inventory export. Output: ~35 CIS-mapped posture findings, severity-ranked.

Network

Network Discovery

nmap / built-in fallback

Host discovery, port and service enumeration and version detection. Uses the system nmap when it is installed, and falls back to a built-in TCP-connect scanner otherwise, so it works anywhere.

Input: an authorized host or range. Output: open ports, services and versions feeding the exposure picture.

Efficiency

Your AI, very few tokens

Sending a whole scan's raw output to a language model is what makes AI security tools expensive. Alphaea inverts that. Deterministic engines do the bulk work and compress what they find into a small, structured summary; only that summary reaches your model. The exact compression technique is proprietary — but the shape of it is simple:

Raw tool output large & noisy ✕ never sent whole to AI Deterministic engines parse & structure the signal — with zero tokens Compact summary a few lines Your AI tiny token cost The model reasons over a small, structured summary — not raw scan dumps — so cost stays a fraction of tools that prompt on everything.
Parse before you prompt: the model reasons over a compact summary, so token cost stays a small fraction of raw-dump tools — with the same model you already pay for.

Because the model is yours, you also choose where it runs. A local model (Ollama / vLLM) means zero egress; a hosted model means only that small summary is exchanged, never your code or data.

Compliance

Frameworks & compliance mapping

Every finding is crosswalked to the frameworks an auditor cares about — OWASP Top 10, CWE, MITRE ATT&CK, CIS Controls v8, NIST 800-53, PCI-DSS 4.0, ISO 27001, OWASP ASVS, HIPAA and SOC 2. A tester picks the frameworks for the engagement; the report and a coverage view then render for exactly those, showing which controls were exercised and where the gaps are. ATT&CK results export as a Navigator layer.

The mapping is deterministic and versioned, and each report cites the authoritative source behind every framework — a mapping methodology built to be defensible in front of an assessor, not a self-issued certificate.

DevSecOps

CI/CD security gate

Alphaea drops into a pipeline as a pass/fail gate. A build runs a scan; Alphaea scores the findings against a policy you set — maximum counts per severity, an optional weighted risk ceiling, which scan types count, and whether only tester-validated findings count. If the policy is breached the gate returns a non-zero exit code and the pipeline stops before the artifact ships. Copy-paste snippets are provided for GitHub Actions, GitLab CI, Jenkins and plain curl.

Gets sharper

The learning flywheel

When your team confirms a finding or marks one a false positive, that decision becomes tenant-local learning data. Alphaea feeds it back so future scans suppress the noise your team already dismissed and lean into what they care about. The flywheel belongs to you — it is never pooled into a vendor model.

Guardrails

Scope, proof & audit

Signed scope

Every engagement runs against a cryptographically signed scope. Anything outside it is refused, fail-closed — the tool cannot wander off-target.

Proof-of-exploit

A dynamic vulnerability is only reported when a working, replayable proof is captured. No proof, no finding.

Hash-chained audit

Actions are recorded in a tamper-evident, hash-chained audit trail, so an engagement can be reviewed after the fact.

Deployment

Where it runs & your data

Alphaea comes in three tiers. On Cloud, your workspace is isolated per-tenant and never used for training. On Hybrid and Sovereign (on-prem), the platform runs inside your environment and — with a local model — no code, traffic, finding or secret crosses your boundary at all. You choose the trade-off between convenience and isolation; the capabilities are the same.

Straight talk

What stays proprietary

This page explains what each part does and how the pieces connect. A few things are intentionally described as validated black boxes, because they are the platform's core IP:

  • The exploit-planning and payload construction logic behind dynamic testing.
  • The token-minimization technique that keeps AI cost tiny across every model.
  • The secret-detection engine (entropy / decoding heuristics).
  • The internals of scope signing and the proof-validation judge.

Everything about inputs, outputs, data flow and coverage is open here; the detection and cost internals stay with us. If you are evaluating Alphaea and need a deeper technical session under NDA, that is available on request.

See it on your own stack

Point Alphaea at a repo or a staging URL, connect your model, and watch a validated finding come back with its proof and framework mapping.

Or email contact@abcaihub.com