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.
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.
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
Maps the reachable surface and where user input is reflected — the raw material every later stage reasons about.
Crawl
Walks the application to discover every page, parameter and form within the crawl limits you set.
Planner
Your connected model turns the surface into concrete, testable hypotheses about likely weaknesses — guided by Alphaea's instruction sets.
Exploit
Safely attempts each hypothesis using scope-gated techniques. Nothing outside the signed scope is ever touched.
Judge
Every attempt is checked for a real, reproducible effect. No proof-of-exploit, no finding — this is what keeps false positives out.
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.
Live Web Application Testing
your AI + validated proof gateExplores 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.
AI Code Review
deterministic + your AIOn 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.
Dependencies & Secrets
deterministic · no tokensParses 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.
Infrastructure as Code
rules + your AIChecks 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 Posture
deterministic · no tokensAudits 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 Discovery
nmap / built-in fallbackHost 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:
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.
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