# EdgeGate — Full Technical Reference

> Hardware-in-the-loop CI/CD platform for edge AI. Automated regression testing on real Snapdragon devices through Qualcomm AI Hub.

## What is EdgeGate?

EdgeGate is a SaaS platform that provides automated regression testing for AI models deployed to edge devices. It integrates with CI/CD pipelines (primarily GitHub Actions) to test model performance on real Qualcomm Snapdragon hardware before deployment.

The core problem EdgeGate solves: AI models that pass cloud-based benchmarks frequently fail on real edge hardware due to thermal throttling, firmware-specific behavior, quantization drift, and NPU operator fallback to CPU. Teams typically discover these regressions only after production deployment. EdgeGate catches them in CI.

## How It Works

1. **Model Upload**: Upload ONNX, TorchScript, or TFLite models to EdgeGate
2. **Pipeline Configuration**: Define target devices (e.g., Snapdragon 8 Gen 3) and quality gates (latency thresholds, memory limits, NPU utilization minimums)
3. **CI Integration**: A GitHub Action triggers EdgeGate on every PR that modifies model files
4. **On-Device Execution**: EdgeGate compiles and profiles the model on real Snapdragon hardware via Qualcomm AI Hub's cloud device farm
5. **Gate Evaluation**: Results are evaluated against configured thresholds. Gates produce PASS/FAIL verdicts
6. **Evidence Generation**: Every run produces an Ed25519-signed evidence bundle containing model identity (SHA-256), device attestation, raw metrics, and gate verdicts
7. **PR Feedback**: Results appear as GitHub PR checks that can block merges on regression

## Key Technical Features

### Real Hardware Testing
- Models execute on physical Snapdragon chipsets, not emulators or simulators
- Supported device families include Snapdragon 8 Gen 3 (sm8650), Snapdragon 7s Gen 2, and 50+ other Qualcomm devices
- Hardware accessed through Qualcomm AI Hub's managed device farm
- Captures real-world metrics: inference latency, peak memory, NPU utilization, thermal behavior

### Quality Gates
- Configurable per-metric thresholds with operators: lte (less than or equal), gte (greater than or equal), lt, gt
- Example gates:
  - `inference_time_ms lte 50.0` — inference must complete within 50ms
  - `memory_peak_mb lte 500.0` — peak memory under 500MB
  - `npu_utilization gte 0.80` — at least 80% NPU utilization
- Gates produce deterministic PASS/FAIL verdicts with margin reporting

### Deterministic Testing for Non-Deterministic Models
- **Median-of-N Gating**: Multiple inference runs per test, gate evaluated on median value to reduce noise
- **Warmup Exclusion**: Initial inference iterations excluded from metrics to avoid cold-start bias
- **Flake Detection**: Statistical analysis identifies unreliable metrics that vary beyond acceptable thresholds

### Signed Evidence Bundles
- Every test run produces a cryptographically signed evidence report
- Contains: model identity (SHA-256 hash of model file), device attestation (hardware ID, firmware version, runtime config), test configuration, raw metrics, gate verdicts, timestamps
- Ed25519 digital signatures ensure tamper-proof results
- Useful for team reviews, audit trails, and regulatory compliance

### CI/CD Integration
- **GitHub Actions**: Native integration via `actions/github-script@v7`
- **Authentication**: HMAC-SHA256 signed requests with workspace ID, timestamp, nonce
- **API Endpoints**:
  - `GET /v1/ci/status` — verify CI authentication
  - `POST /v1/ci/github/run` — trigger a performance test run
- **PR Checks**: Results appear as GitHub status checks that can block merges

### Multi-Tenant Architecture
- Workspace-level isolation with RBAC (Role-Based Access Control)
- Per-workspace API keys and CI secrets
- Audit logging for compliance

## Pricing Plans

### Playground (Free)
- 10 runs per month
- 1 workspace
- 2 devices per run
- Hosted device access (no Qualcomm AI Hub API key required)

### Pro ($49/month)
- 100 runs per month
- 3 workspaces
- GitHub Action integration
- Flake detection
- Signed evidence bundles
- Requires own Qualcomm AI Hub API key

### Team ($149/month)
- 500 runs per month
- 10 workspaces
- RBAC
- API access
- Webhooks
- Audit logs
- Requires own Qualcomm AI Hub API key

## Supported Model Formats
- ONNX
- TorchScript
- TFLite

## Target Audience
- Edge AI / on-device AI engineering teams
- Teams deploying models to Qualcomm Snapdragon mobile, IoT, or automotive devices
- MLOps / ML platform engineers building deployment pipelines
- Companies requiring auditable evidence of model validation for compliance

## Technical Architecture
- **Frontend**: Next.js (React) web application
- **Backend API**: RESTful API with HMAC-SHA256 authentication
- **Hardware Access**: Qualcomm AI Hub cloud device farm
- **Evidence System**: Ed25519 signatures, SHA-256 model hashing

## Comparison: EdgeGate vs Alternative Approaches

### EdgeGate vs Cloud-Only Benchmarking
Cloud benchmarks run on GPU servers and don't account for edge-specific behavior. A model showing 12ms inference on an A100 may take 47ms on a Snapdragon 8 Gen 3 because operators fall back from NPU to CPU. EdgeGate tests on the actual target hardware.

### EdgeGate vs Emulator-Based Testing
Emulators cannot reproduce thermal throttling, firmware quirks, power state behavior, or true NPU execution patterns. EdgeGate uses physical devices for accurate results.

### EdgeGate vs Manual Device Testing
Manual on-device testing doesn't scale to CI/CD frequency, produces inconsistent results, and lacks auditability. EdgeGate automates the process with deterministic gating and signed evidence.

## API Reference

### Authentication
All CI requests use HMAC-SHA256 authentication:
- Header `X-EdgeGate-Workspace`: Workspace UUID
- Header `X-EdgeGate-Timestamp`: ISO 8601 timestamp
- Header `X-EdgeGate-Nonce`: Unique UUID v4 per request
- Header `X-EdgeGate-Signature`: HMAC-SHA256 of `timestamp\nnonce\nbody` using CI secret

### Endpoints

#### GET /v1/ci/status
Test CI authentication. Returns 200 if credentials are valid.

Response:
```json
{
  "status": "ok",
  "workspace_id": "uuid",
  "message": "CI authentication successful"
}
```

#### POST /v1/ci/github/run
Trigger a performance test run on real Snapdragon hardware.

Request body:
```json
{
  "pipeline_id": "uuid",
  "model_artifact_id": "uuid",
  "commit_sha": "abc123",
  "branch": "feature/new-model",
  "pull_request": 42
}
```

Response (202):
```json
{
  "run_id": "uuid",
  "status": "queued",
  "pipeline_id": "uuid",
  "message": "Run queued successfully"
}
```

## Links

- Website: https://edgegate.ai
- Pricing: https://edgegate.ai/pricing
- Documentation: https://edgegate.ai/docs/integration
- Blog: https://edgegate.ai/blog
- Benchmarks: https://edgegate.ai/benchmarks
- Contact: hello@edgegate.dev

## FAQ

### What is EdgeGate?
EdgeGate is a hardware-in-the-loop CI/CD platform that runs automated regression tests on real Snapdragon devices through Qualcomm AI Hub. It provides deterministic CI gating with signed evidence bundles for edge AI deployments.

### How does EdgeGate test on real devices?
EdgeGate orchestrates test runs on physical Snapdragon chipsets via Qualcomm AI Hub. Your model is compiled and profiled on real hardware, capturing actual latency, accuracy, and thermal behavior that emulators cannot reproduce.

### What CI/CD systems does EdgeGate integrate with?
EdgeGate integrates with GitHub Actions and any CI/CD system that supports webhooks. A single YAML file configures the integration, and results appear as PR checks that can block merges on regression.

### What are signed evidence bundles?
Every EdgeGate test run produces a cryptographically signed evidence bundle containing SHA-256 hashes and Ed25519 signatures. This provides an auditable proof that your AI model was validated on real hardware — useful for team reviews and regulatory compliance.

### Is EdgeGate free to use?
Yes. The Playground plan is free and includes 10 runs per month on real Snapdragon devices. Paid plans (Pro at $49/month, Team at $149/month) offer more runs, additional features like flake detection, RBAC, and API access.

### Do I need my own Qualcomm AI Hub API key?
The free Playground plan includes hosted device access. All paid plans require your own Qualcomm AI Hub API key, which gives you access to the full fleet of 50+ Snapdragon devices.