
HackITAutonomous Cloud Architect is a Chrome extension plus backend that adds an AI chat panel to cloud.linode.com. A developer types "I need a secure data scraping environment in Seattle," and the agent builds it across Akamai Cloud while they watch. User and task: developers and small teams who need a locked-down environment (server, network rules, storage, record keeping) without clicking through five Cloud Manager pages. What it does, with one sentence: - Creates a VPC and a 1 GB Ubuntu 24.04 Linode in Seattle. - Creates a default-drop Cloud Firewall that allows SSH only from the requester's own IP and HTTPS from anywhere. - Creates a private Object Storage bucket with a key limited to that bucket, and uploads a manifest. - Records the environment in Managed PostgreSQL. - Answers "what have I built?" from PostgreSQL, answers read-only account questions, and tears everything down on request. A full build takes about 35 seconds and a teardown about 23. - An Activity tab shows Akamai's own event history (done, in progress, failed) next to the chat. How the services are used: Akamai Inference (qwen3-8-27b) does tool calling and chains eight tools, passing real IDs between steps. Compute runs the backend 24/7 and hosts each environment. PostgreSQL is the environment registry that teardown depends on, plus a chat audit log. Object Storage holds an append-only JSON archive of every chat turn plus each environment's manifest. Firewall and VPC secure each environment. Technical choices: API keys stay on the backend and the extension holds only a shared key. Tool errors are returned as text so the model can recover. The agent protects what it runs on: it refuses to tear down its own host Linode, firewall, database and audit bucket unless the user types an exact confirmation phrase. Checked by: a full build and teardown through the extension backend; asking for something the agent has no tool for (a Kubernetes cluster), which it declined; and asking to delete an environment that does not exist, which it reported as missing. Known limits: plain HTTP with one shared key, fixed regions (Linode in Seattle, buckets in Chicago), one environment per VPC address, no login or per-user permissions, no retention rules on the audit logs.
AkamaiAkamai Inference (qwen3-8-27btool calling)+6

Team1264Mithra Security Mithra is a social-engineering risk scanner for GitHub repos. It warns you when an open-source project your app depends on is being taken over, before any malicious code is introduced. Live: · (venue network only) Repo: Team: Petr Kirsanov and Mikhail Kirsanov Named after the Persian god Mithra, who has a thousand ears and ten thousand eyes and cannot be deceived. Why In 2024 a backdoor in xz Utils (CVE-2024-3094) nearly reached millions of Linux servers. It was the last step of a two-year con: in 2022, new accounts on the public xz-devel mailing list pressed the tired, unpaid maintainer to hand over control. Security scanners read code. This attack showed up first in conversation, and Mithra reads the conversation. User and benefit Developers and security teams who ship apps built on open-source libraries. Paste a GitHub repo and every dependency gets a 0–100 takeover-risk score, with the exact public quotes and links behind it. Watched repos are re-scanned every night. Akamai Cloud services - Linode (Nanode, Seattle): runs the FastAPI app, plus a nightly systemd timer that re-scans watched repos and records risk history. - Managed PostgreSQL 18 + pgvector: scans, risk history, signals, a shared model-result cache, and the 2022 xz pressure emails as embeddings for similarity search. - Object Storage: the evidence. Each project's fetched activity, every scan report and the xz replay dataset, opened from the dashboard through one-hour signed links. - Cloud Firewall: only ports 22 and 80, only from the venue network. - DNS Manager: serves mithrasec.com. - Cloud Inference: three models, below. Inference - qwen3-8-27b tags signals (maintainer burnout, pressure campaign, control handover) as JSON matched to a schema. - gemma-4-26b-a4b-it reads the xz-devel mailing list month by month. Its 262k-token context fits whole threads. - qwen3-embedding-8b + pgvector finds messages close to the 2022 xz pressure emails. Technical choices - Code computes the score, not the model, with fixed weights. The model only finds and quotes signals. Code adjusts each one with GitHub facts: burnout counts only when a maintainer says it, pressure from a brand-new account counts 1.5×, from a known contributor 0.5×. - Caching: model results are cached by content hash in PostgreSQL, shared by the laptop and the server, to protect the shared AI key and GitHub's rate limit. - Least privilege: the server never holds the account token, the storage key reaches one bucket, and the database accepts only the Linode (IPv4 + IPv6) and our laptop. Our idea Existing tools read code or count activity, so they alert after a bad release. Mithra reads the conversation and catches the pressure campaign before the handover: for xz, about two years before the backdoor. It flags situations and shows the evidence behind every flag. Demo 1. mpld3/mpld3, live this month: high (85). Two weeks after its maintainer asked publicly for help, a brand-new account offered to take over triaging issues and reviewing pull requests. The maintainer then warned 10 other repos where the same account had made offers. 2. binbin2000/icloudpd-manager: 14 of 16 dependencies score low. icloudpd scores high (60): its maintainers posted "Looking for new MAINTAINER for the project". 3. xz replay tab, press Play: the risk turns red in May 2022.
AkamaiPython 3.11FastAPI+11
Bots are already in group chats and community threads, and they don’t read like bots. AI makes fluent, personal, even typo-prone accounts cheap, so “spot the robotic writing” no longer works as advice. Prebunking games like Bad News show that practicing against manipulation tactics helps, but their content is scripted, so players never face adversaries that adapt, argue back or frame innocent people. And nobody has data on which manipulation tactics actually fool people. We designed a simulation game designed model and practice differentiating AI bots from real humans. You join a fictional town’s group chat during a breaking local event. Six accounts react, all written live by an open-weight model on Akamai Cloud Inference. One or two are bots pushing a false story; the rest are honest neighbors who make typos, overreact and misread things. Because every account is AI-written, writing style gives nothing away, just like real feeds today. The only way to win is to judge behavior. Investigate. DM any account, and spend limited Fact-Check Tokens on Account Age, Source Check and Posting Pattern. Decide. Call an emergency meeting and vote an account out before the rumor spreads across the town. Ejecting an honest human costs you points, so suspecting everyone doesn’t win. Learn. A reveal screen shows every bot post tagged with its tactic (invented insider, fake urgency, coordinated amplification, accusing others) and a Bot Radar summary of which tactic fooled you. The bots are live open-weight models that adapt between rounds. They are caught by behavior, not writing style. Akamai Cloud: Cloud inference: every character post, DM reply, and meeting defense Managed PostgreSQL: every finished game is stored, and the live Tactics Stats page reads from it Object Storage: each game becomes a replay card, opened by QR code on a phone Computer (Linode) + Cloud Firewall: the public HTTPS app Our game creates an interactive platform that can help people practice judging sources and behavior, helping people develop the skills necessary to detect false- and mis-information as AI continues to progress.
AkamaiTypeScriptReact 19+9
peppaPigSnap & Claim is a lost-and-found prototype for events that helps people find their belongings while keeping item photos private during search. A finder submits a photo. Akamai Cloud Inference uses Gemma vision to suggest a public description and a private proof question. An owner searches in natural language; Qwen embeddings rank likely matches without showing photos. The owner answers a question about a distinguishing detail, and a Qwen chat model evaluates the answer. A passing answer allows the app to reveal a photo, but staff must still verify ownership in person before releasing the item. Akamai Managed PostgreSQL with pgvector stores inventory, claim attempts, and embeddings; private Object Storage holds photos with short-lived signed links. The repository also includes an example systemd service for Linode. This is a prototype: use staged photos only. AI verdicts are leads, not proof of identity, and the shared staff PIN is not sufficient for an internet-facing service.
AkamaiPythonPostgreSQL+4

NBainbridgekalshi hedge
Sahil Bhatt's teamCascadeIQ Virtual resilience audit: AI interprets an incident → deterministic simulation → AI mitigation → verified rerun. Hackathon prototype (Akamai Seattle AI Hackathon, Nov 2026). Repo: Demo: (uv run serve.py) Active branch: main Judging 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 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 and 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 Do not commit .env or API keys. See deploy/PROVISIONING.md for Linode + Managed Postgres checklist.
AkamaiLINODE API
HeyoCloudHand 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. 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 Use your Mac Open the local Mac workspace 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. Open Use npm test to run the automated checks.

RAlexander Picón's teamLabStrata 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.
AkamaiNode.js with plain HTMLAkamai Inference (Qwen to check+6
EmFPromptVeil is an Edge AI Security Gateway (Prompt WAF) built on Akamai Cloud that sits between users and Large Language Models (LLMs). Just as a Web Application Firewall protects web apps from SQL injection and credential theft, PromptVeil inspects every prompt before it reaches an upstream LLM—masking leaked secrets/PII in under 1 millisecond, blocking adversarial prompt injections and jailbreaks, quarantining forensic attack payloads in Akamai Object Storage, and logging every event to Akamai Managed PostgreSQL for compliance auditing. User and task: Enterprise security, engineering, and operations teams who need fast, safe LLM adoption without the risk of accidental PII/secret leaks (emails, SSNs, credit cards, OpenAI/AWS keys) or adversarial prompt injection. Benefit: Eliminates data exfiltration and jailbreaks before sensitive data ever reaches upstream models, combining sub-millisecond deterministic redaction with full audit compliance in a live SOC dashboard. Services: Akamai Cloud Inference (qwen3-8-27b for JSON-constrained guardrail inspection and safe downstream reasoning), Akamai Object Storage (S3-compatible E3 bucket with limited-access keys storing forensic JSON quarantine payloads for blocked attacks), Akamai Managed PostgreSQL (compliance audit logs and risk telemetry), Akamai Linode (Ubuntu 24.04 hosting the live SOC gateway via systemd), and Akamai Cloud Firewall (restricting ingress on ports 22 and 80). Inference: qwen3-8-27b via Akamai's OpenAI-compatible serverless inference API ( using JSON-constrained classification (temperature=0.1) to score injection risk (0.00–1.00), verified across benign passthrough, redacted PII leak, and adversarial prompt injection test cases. Technical choice: Dual-tier WAF-style pipeline—deterministic regex redaction (measured 0.03–0.22 ms) for zero-latency secret masking paired with LLM semantic injection detection, plus automatic SQLite and local-folder resilience fallbacks. Our idea: Treat enterprise AI security like an edge Web Application Firewall (WAF) natively powered by Akamai Cloud. Demo: Live Akamai-themed SOC dashboard ( showcasing 3 interactive scenarios: (1) Normal query passthrough (PASSED), (2) Real-time PII & API key redaction with a side-by-side diff (REDACTED & PASSED—4 secrets masked before upstream inference), and (3) Prompt injection block (403 BLOCKED — INJECTION QUARANTINED) with live Akamai Object Storage forensic JSON inspection and Akamai Managed PostgreSQL compliance audit logs. Known limits: Added latency (2–3s) from the Tier 2 semantic guardrail LLM call; next iteration will deploy Tier 1 redaction and a lightweight classifier directly inside Akamai Functions (WebAssembly) at the edge.
AkamaiPythonStreamlit+7
A tool call agent that can forecast inventory stock out's and demand spikes in supply chain and recommend new reorder point and potential time of demand spike based on regions
AkamaiVS Code
SlantheoryWEATHER RUNNER is a verified meteorological and edge-dispatch operations agent built on Akamai Cloud Serverless Inference (qwen3-8-27b) and Akamai Object Storage (S3 API). Operators upload mission dispatch logs to Akamai Object Storage, complete a human pre-launch pacing gate, and trigger multi-tool orchestration across live National Weather Service (api.weather.gov) telemetry, cloud object manifests, and Linux host diagnostics-backed by deterministic NLP entity extraction that audits every AI response with a real-time Grounding Confidence score and inspectable protocol trace.
AkamaiAkamai Cloud Serverless Inference (qwen3-8-27b)Akamai Object Storage (S3 API)+10
R
Fantastic Three LKG: Last Known Good Most outages are caused by a change. LKG puts a service back on its last known-good config within seconds, with no model in that path. Then it asks a model what broke and ships a fixed config that keeps the change the team actually wanted. User: the on-call engineer on a small team with no 24/7 coverage. A bad config deploy has taken the service down. They need it back up, and they need to know why it broke. Result in the recorded cloud run: the shop was back online 6.6 s after its first failed health check. The intended change (a Black Friday banner) was live again, without the bad setting, at 13.2 s. The incident was recorded in PostgreSQL. No human was involved. Video of the full run (30 s, 1920×1080): docs/lkg-demo-cloud.mp4 How it works One incident, step by step | # | Step | What happens | Model? | |---|---|---|---| | 1 | Deploy | Someone pushes a config through the sidecar's /deploy. The sidecar checks that it parses as TOML, then atomically swaps app.toml (temp file + os.replace). The app picks it up on its next request. No restart. | no | | 2 | Detect | agent.py checks GET /health every 2 s. Three failures in a row (about 4 s) open an incident. The agent reads the bad config and the last 50 log lines from /state, then inserts an open incident row. | no | | 3 | Roll back | /rollback takes the newest object under snapshots/ in the bucket and swaps it in. The agent waits for 3 consecutive healthy checks, 1 s apart. Time to recovery is measured from the first failed check to that point. | no | | 4 | Triage | One qwen3-8-27b call (plus one retry on error) with the logs, the bad config and the restored good config. It returns JSON {cause, summary, confidence, patched_config}. | yes | | 5 | Patch | If the cause is known and confidence ≥ 0.5, the patch is checked: it must parse, have the same keys as the good config, and keep each value's type. It is then deployed through the same /deploy a human uses. | no | | 6 | Verify | 3 consecutive healthy checks within 20 s gives patched. Otherwise the agent rolls back once more and stops (patch_failed). An unknown cause or low confidence leaves it rolled back for a human (rolled_back). | no | Why the newest snapshot is safe to restore The sidecar saves a config to the bucket only after it has been healthy for 30 s in a row (SNAPSHOT_AFTER_S), and only if app.toml hasn't changed in that time. A bad deploy logs snapshot skipped and never reaches the bucket. So a rollback can take the newest object without checking anything. A patch that stays healthy for 30 s becomes the next known-good snapshot. Design choices - Rollback never depends on the model. Detect → roll back → recover uses only HTTP and Object Storage. The model runs after the service is already healthy. Inference, database and event-file errors are caught and logged; they never stop a rollback. - The healer doesn't run on the box it heals. The agent is on its own VM. The sidecar on the App VM only carries out deploys, rollbacks and snapshots. - Least privilege. The App VM holds only the bucket key, limited to that one bucket. The Agent VM holds the Inference key, the PostgreSQL password and the sidecar token. - Network lock-down. Both firewalls drop inbound traffic by default. Port 9000 (sidecar) accepts only the Agent VM. Port 80 accepts your IP and the Agent VM (or everyone, with -var app_open_to_world=true, so judges can open the shop). SSH accepts only your IP. PostgreSQL allows only your IP and the two VMs. - It never loops. Each incident gets at most one patch, followed by at most one more rollback. Akamai services used | Service | Role | |---|---| | 2 × Linode Nanode (Seattle) + 2 Cloud Firewalls | App VM (shop + sidecar), Agent VM (agent + dashboard) | | Object Storage (Chicago) | Known-good snapshots, kept off both VMs | | Managed PostgreSQL 17 (Seattle) | One row per incident: health reason, logs, bad config, snapshot, time to recovery, cause, summary, confidence, patch, outcome (open / rolled_back / patched / patch_failed / failed) | | Akamai Inference, qwen3-8-27b | temperature=0, JSON-schema response format, max_tokens=500 | Run the demo (Akamai Cloud) Prerequisites: uv, OpenTofu, curl, ssh. nix develop (or direnv) provides all of them. Copy .env.example to .env and fill in LINODE_TOKEN and the AKAMAI_ values. Tofu generates everything else. Open and press Break: db pool = 0 (or b). The screen shows the incident live: - the shop as a shopper sees it; - a "back online" clock and a "change shipped" clock; - a map of the Akamai services that lights up with each call the agent makes. Every deploy, rollback and patch enters the App VM through the firewall gate on :9000, reaches the sidecar, and ends with the sidecar writing app.toml and the shop reading it; - a timeline with the no-model rollback bracketed; - a bad / known-good / patched diff of what the model changed; - the agent's log. | Dashboard control | Effect | |---|---| | Break: db pool = 0 (b) | Deploys config/bad-pool.toml: the Black Friday banner plus db_pool_size = 0 | | Break: timeout = 10 ms (t) | Deploys config/bad-timeout.toml: request_timeout_ms = 10 | | Reset to good (g) | Deploys config/good.toml. Wait 30 s for its snapshot before the next break. | The agent's terminal shows the same run: Other commands: Offline backup The dashboard records every live session as JSON lines. A replay plays the last incident in the file on the same screen, with the original timing. It needs no network and no .env: Flags: --speed (replay speed), --port (default 8700), --no-record. Run it locally The sidecar needs a real Object Storage bucket (the OBJ_ values). PostgreSQL is optional: without PGHOST, the agent skips the database and incident numbers show as #-. Evaluation uv run eval.py runs the agent's triage prompt (copied from agent.py) against 4 frozen incidents in eval/cases.json. One of them is an incident the config doesn't explain. A case passes when the cause is right and the patch reverts only that key, keeping every other change. For the unexplained case, it passes when the model hands it to a human (cause unknown or confidence < 0.5). Don't run the eval right before a demo: it uses the shared per-minute token budget. Repository layout | Path | What it is | |---|---| | app.py | The shop. Re-reads app.toml on every request. /health returns 503 with the reason (db_pool_size ≤ 0 or request_timeout_ms < 50). | | sidecar.py | App VM. /deploy, /rollback, /state, all token-protected. Uploads known-good snapshots to the bucket. | | agent.py | Agent VM. Watches, rolls back, triages, patches, records. --history prints the last 5 incidents. | | dashboard.py, dashboard.html | The incident screen, live or replayed. Read-only, except for its Break/Reset buttons. | | eval.py, eval/cases.json | Frozen-incident eval for the triage prompt. | | config/ | good.toml and the two bad deploys (bad-pool.toml, bad-timeout.toml). | | infra/main.tf | OpenTofu: every cloud resource, plus the gitignored .env. files and SSH key. | | deploy/ | lkg.sh (setup, push, agent, dashboard, recording, history, snapshots), cloud-init that installs uv, systemd units for app and sidecar. agent.service is installed but not enabled, because the demo runs the agent in tmux so you can watch it. | | docs/ | Demo video, final screenshot, and the dashboard recording used for --replay. | | LKG-PLAN.md | The original design plan, kept for history. The code and this README are the current reference. | | flake.nix, .envrc | Nix dev shell: uv, Python, OpenTofu, linode-cli, psql, s3cmd, tmux. | Each .py is a single-file uv script that declares its own dependencies (Python ≥ 3.11). Known limits - Config-only. It handles config changes only, and the patch can only revert keys to their known-good values. It covers one app. - Plain HTTP between the VMs. The sidecar token is sent unencrypted; the firewall is what keeps others out. - "Known-good" means healthy for 30 s. A failure that only shows up later would still be snapshotted. - Empty bucket. Until the first snapshot exists, /rollback returns 409 and the agent pages a human.
Akamaipythonuv+2