Projectmeetup

Built at [Seattle] Build with Akamai Cloud at GitHub Bellevue

Retry Storm

# CascadeIQ Virtual resilience audit: **AI interprets** an incident → **deterministic simulation** → **AI mitigation** → **verified rerun**. Hackathon prototype (Akamai Seattle AI Hackathon, Nov 2026). **Repo:** https://github.com/Sahil9477/CascadeIQ **Demo:** http://127.0.0.1:8000/ (`uv run serve.py`) **Active branch:** `main` ## Judging ```text User and task: CS / cloud students (and judges) learning why retry storms break checkout paths; they run Lab 01, see the outage, pick a mitigation, and verify it. Benefit: Turns an abstract SRE failure into a hands-on lab: AI proposes, deterministic sim proves, shareable /runs/{uuid} for grading. Services: Akamai Inference (Qwen interpret + recommend; Gemma chart review); Managed Postgres (persist audit runs / share links); Linode Types API (published compute pricing beside outage loss). App can run on a Linode VM (deploy/) — laptop demo uses serve.py. Inference: qwen3-8-27b for scenario JSON + allowlisted mitigation; gemma-4-26b-a4b-it reads the before chart as a hint (metrics win). Checked by same-seed Python verify and fixture vs live flags (inference_used). Technical choice: Simulator owns truth — models never invent metrics; allowlist + re-sim with same seed so AI can’t fake a win. Our idea: Scenario-first teaching lab (Build → Cost → Break → Fix → Learn), two-model diagnose with Python as the judge. Demo: Start Lab → untick fixtures → Run audit → Ask Qwen → Verify → Save → open /runs/{uuid}. Known limits: No public Linode app URL until Nanode is provisioned; shared minute token budget (429); retry_cap_reduction may show clearer wins than backoff alone. ``` ## Team | Owner | Owns | |---|---| | **Sahil** | Deterministic simulator, Qwen interpret/recommend, FastAPI `/api/interpret\|audit\|recommend\|verify`, contracts/fixtures, Lab 01 + catalog/cost panel | | **Danny** | Interactive dashboard (`static/` instrument), Postgres `/api/runs`, `serve.py`, Linode `deploy/` | ## Quick start ```bash cd ~/Desktop/CascadeIQ git checkout main cp .env.example .env # paste AKAMAI_API_KEY + PG* from workshop / Cloud Manager (never commit .env) uv sync --extra dev uv run serve.py # Lab UI: http://127.0.0.1:8000/ # OpenAPI: http://127.0.0.1:8000/docs # Health: http://127.0.0.1:8000/api/health # Engine-only (no Postgres overlay): # uv run uvicorn cascadeiq.api.main:app --reload --port 8010 uv run pytest -q uv run python scripts/demo_flow.py # live Qwen + sim uv run python scripts/demo_flow.py --fixture uv run python scripts/smoke_runs_db.py # POST/GET /api/runs when PG* set ``` ### Lab 01: The Retry Storm Open `/` after `serve.py` starts. **Start Lab** loads the Gateway→Orders→Payments demo. Leave **Use fixtures** unticked for live Qwen/Gemma; tick it for offline rehearsal (`inference_used` is always shown honestly). Flow: Start Lab → **Run resilience audit** → **Ask Qwen for a mitigation** (Gemma chart review → informed recommend) → **Verify** → **Save** → open `/runs/{uuid}`. Play streams the audit timeline only after a baseline exists. Cost panel uses published Linode types (`GET /api/catalog/compute?region=us-sea`) beside simulated outage loss — never invents prices. ## API See [`docs/cascadeiq-api-contracts.md`](docs/cascadeiq-api-contracts.md) and [`contracts/`](contracts/). - `POST /api/interpret` — Qwen → scenario JSON - `POST /api/audit` — baseline sim time series + metrics - `GET /api/catalog/compute?region=us-sea` — published Linode types (`source: live|unavailable`) - `POST /api/chart/review` — Gemma reads the chart (advisory) - `POST /api/recommend` / `POST /api/recommend/informed` — allowlisted mitigation (optional visual note) - `POST /api/verify` — same seed + mitigation deltas - `POST /api/runs` · `GET /api/runs/{uuid}` — Postgres persist + share (via `serve.py`) Mitigations allowlist only: `bounded_exponential_backoff_seeded_jitter` | `retry_cap_reduction`. ## Layout ``` cascadeiq/engine/ # simulator + schemas cascadeiq/inference/ # Akamai Qwen client cascadeiq/api/ # FastAPI intelligence endpoints checks/ # Gemma chart review + informed recommend (Danny) cloud/ # Postgres /api/runs (Danny) serve.py # production entry: app + runs + static static/ # Lab UI + instrument deploy/ # Linode service + deploy.sh contracts/ fixtures/ ``` Do not commit `.env` or API keys. See [`deploy/PROVISIONING.md`](deploy/PROVISIONING.md) for Linode + Managed Postgres checklist.

View source
// latest_project_recording.mp4
// Project brief

# CascadeIQ Virtual resilience audit: **AI interprets** an incident → **deterministic simulation** → **AI mitigation** → **verified rerun**. Hackathon prototype (Akamai Seattle AI Hackathon, Nov 2026). **Repo:** https://github.com/Sahil9477/CascadeIQ **Demo:** http://127.0.0.1:8000/ (`uv run serve.py`) **Active branch:** `main` ## Judging ```text User and task: CS / cloud students (and judges) learning why retry storms break checkout paths; they run Lab 01, see the outage, pick a mitigation, and verify it. Benefit: Turns an abstract SRE failure into a hands-on lab: AI proposes, deterministic sim proves, shareable /runs/{uuid} for grading. Services: Akamai Inference (Qwen interpret + recommend; Gemma chart review); Managed Postgres (persist audit runs / share links); Linode Types API (published compute pricing beside outage loss). App can run on a Linode VM (deploy/) — laptop demo uses serve.py. Inference: qwen3-8-27b for scenario JSON + allowlisted mitigation; gemma-4-26b-a4b-it reads the before chart as a hint (metrics win). Checked by same-seed Python verify and fixture vs live flags (inference_used). Technical choice: Simulator owns truth — models never invent metrics; allowlist + re-sim with same seed so AI can’t fake a win. Our idea: Scenario-first teaching lab (Build → Cost → Break → Fix → Learn), two-model diagnose with Python as the judge. Demo: Start Lab → untick fixtures → Run audit → Ask Qwen → Verify → Save → open /runs/{uuid}. Known limits: No public Linode app URL until Nanode is provisioned; shared minute token budget (429); retry_cap_reduction may show clearer wins than backoff alone. ``` ## Team | Owner | Owns | |---|---| | **Sahil** | Deterministic simulator, Qwen interpret/recommend, FastAPI `/api/interpret\|audit\|recommend\|verify`, contracts/fixtures, Lab 01 + catalog/cost panel | | **Danny** | Interactive dashboard (`static/` instrument), Postgres `/api/runs`, `serve.py`, Linode `deploy/` | ## Quick start ```bash cd ~/Desktop/CascadeIQ git checkout main cp .env.example .env # paste AKAMAI_API_KEY + PG* from workshop / Cloud Manager (never commit .env) uv sync --extra dev uv run serve.py # Lab UI: http://127.0.0.1:8000/ # OpenAPI: http://127.0.0.1:8000/docs # Health: http://127.0.0.1:8000/api/health # Engine-only (no Postgres overlay): # uv run uvicorn cascadeiq.api.main:app --reload --port 8010 uv run pytest -q uv run python scripts/demo_flow.py # live Qwen + sim uv run python scripts/demo_flow.py --fixture uv run python scripts/smoke_runs_db.py # POST/GET /api/runs when PG* set ``` ### Lab 01: The Retry Storm Open `/` after `serve.py` starts. **Start Lab** loads the Gateway→Orders→Payments demo. Leave **Use fixtures** unticked for live Qwen/Gemma; tick it for offline rehearsal (`inference_used` is always shown honestly). Flow: Start Lab → **Run resilience audit** → **Ask Qwen for a mitigation** (Gemma chart review → informed recommend) → **Verify** → **Save** → open `/runs/{uuid}`. Play streams the audit timeline only after a baseline exists. Cost panel uses published Linode types (`GET /api/catalog/compute?region=us-sea`) beside simulated outage loss — never invents prices. ## API See [`docs/cascadeiq-api-contracts.md`](docs/cascadeiq-api-contracts.md) and [`contracts/`](contracts/). - `POST /api/interpret` — Qwen → scenario JSON - `POST /api/audit` — baseline sim time series + metrics - `GET /api/catalog/compute?region=us-sea` — published Linode types (`source: live|unavailable`) - `POST /api/chart/review` — Gemma reads the chart (advisory) - `POST /api/recommend` / `POST /api/recommend/informed` — allowlisted mitigation (optional visual note) - `POST /api/verify` — same seed + mitigation deltas - `POST /api/runs` · `GET /api/runs/{uuid}` — Postgres persist + share (via `serve.py`) Mitigations allowlist only: `bounded_exponential_backoff_seeded_jitter` | `retry_cap_reduction`. ## Layout ``` cascadeiq/engine/ # simulator + schemas cascadeiq/inference/ # Akamai Qwen client cascadeiq/api/ # FastAPI intelligence endpoints checks/ # Gemma chart review + informed recommend (Danny) cloud/ # Postgres /api/runs (Danny) serve.py # production entry: app + runs + static static/ # Lab UI + instrument deploy/ # Linode service + deploy.sh contracts/ fixtures/ ``` Do not commit `.env` or API keys. See [`deploy/PROVISIONING.md`](deploy/PROVISIONING.md) for Linode + Managed Postgres checklist.

// Built with
AkamaiLINODE API
// Watch & explore
// More from this event

Keep exploring what builders shipped.

All projects →

Bainbridge

hedgefinder

kalshi hedge

Heyo

CloudHand

# CloudHand CloudHand gives an AI agent a computer it can use from a browser. Run jobs on an Akamai cloud computer that keeps working after you close the tab, or use your Mac to open local apps and run tasks with your installed Codex skills. ## Try the demo 1. Open the [public judge workspace](https://cloudhand-judges.66-175-217-106.sslip.io/). No sign-in is required. 2. Ask **Calculate 27 × 14 in Calculator** and choose **Confirm action**. 3. CloudHand opens Calculator on Akamai and reports the result, **378**, in the chat. You can also find the completed run under **Akamai computer → Runs**. [Watch the 35-second walkthrough](CloudHand-Demo.mp4) ## Use your Mac Open the [local Mac workspace](http://127.0.0.1:4317/) while CloudHand is running on your Mac. Try **Open Notes on my Mac** or **Open Downloads in Finder**. Your Mac needs to be awake and have the permissions required for the action. To use an installed Codex skill, sign in to the Codex CLI on your Mac, choose **Model → Codex on this Mac**, then select a skill under **+ → Plugins & skills**. ## Run from source From the CloudHand repository, use Node.js 24, npm, and Python 3.10 or later. ```sh npm ci npm run build npm start ``` Open [http://127.0.0.1:4317/](http://127.0.0.1:4317/). Use `npm test` to run the automated checks.

Alexander Picón's team

LabStrata Verify

LabStrata Verify checks a lab's run log against the SOP it was supposed to follow, and tells you which steps never got written down. We started from a problem that's boring but real: the FDA's most-cited drug-inspection finding is not following written procedures. Labs still keep a lot of that record in paper notebooks and free text, so a skipped step can sit there unnoticed until an audit. Here's what happens in our demo. A protocol is saved as a version with a SHA-256 hash, and an assignment pins that exact version to a person. They scan a QR code, take a photo of their handwritten notebook page on their phone, and it uploads straight to Akamai Object Storage. Gemma reads the photo line by line, and if a line is unreadable it says so and asks for a retake instead of guessing. Qwen then compares the log to the SOP. In our sample, Step 4 says to balance the rotor within 0.1 g, but the notebook never records any tube masses. The result says "Not documented: Step 4. Balance the rotor" and highlights the SOP line and the notebook line side by side. We didn't want to trust the model blindly, so a few things are checked in code. Every quote the model cites is matched back against the source text, every SOP step has to get a finding, and the tube-mass tolerance is plain arithmetic. When a reviewer signs, the record is written to an Object Lock bucket. There's a "try to alter this record" button that really attempts the delete, and Akamai returns AccessDenied. The AI checker also gets scored against test cases. One server runs a deliberately worse prompt, fails its score, and the load balancer's health check takes it out, so reviews pause instead of quietly giving wrong answers. Akamai pieces we use: Inference (qwen3-8-27b, gemma-4-26b-a4b-it, qwen3-embedding-8b), Managed PostgreSQL with pgvector over a VPC, Object Storage with Object Lock, two Linodes behind a NodeBalancer, and Cloud Firewall. It's meant to help a person who signs off, not replace them. The photo always stays next to the result so they can check it.

Akamai