Discover AI Applications

Browse applications built on modern technologies. Explore PoC and MVP applications created by our community and discover innovative use cases for modern technologies.

Detonation Chamber

Run an untrusted npm/PyPI package, GitHub repo, or URL in a sealed, disposable Vultr sandbox. Watch what it does and get a verdict based on its actual behaviour. Every escape attempt is contained and recorded.

Builders Nepal

VULTR

Ghostfox Zero: Browser Agent

A sandboxed browser agent powered by our own Firefox engine. True agentic loop with vision verification, human approval gate, and MCP endpoint for AI agents.

autokeren

AgentOpsAIMLVULTR

Airlock: Blast-Radius-Zero Code Agent

Airlock is a web agent that writes and runs code in a disposable sandbox: a policy gate with human approval, no network or secrets, self-healing from real errors, independent verification, and a receipt for every run.

AmberNeel

VULTR

BlastBox - Containment-First Code Agent

BlastBox is a web agent that does real work safely: it plans a task, writes Python, runs every step in a throwaway 8-layer sandbox, self-heals on errors and answers only from executed output, with SHA-256 receipts.

Raja Hassaan Solo

VULTRGemini AI

AgentRush — Blast Radius Zero

A web agent that performs real work — plans tasks, fetches pages, runs generated code — with every action contained inside a fresh throwaway Docker sandbox on Vultr.

AgentRush - Kosoyy

VULTRDeepSeek V3OpenAI+1

Trajectory — Decision-Guided Delivery

Trajectory turns a customer problem into a reviewable software outcome: choose an option in GitHub, generate a bounded change, and inspect independent checks tied back to the original issue.

ProofCell

VULTRQwen3

ProveRun

Web agent: ask → Vultr Inference writes Python → disposable Docker sandbox runs it → real stdout + explanation. Blast Radius Zero / Pattern A.

peterzhou

VULTRAgentOpsopen-interpreter+1

Evidence-Gated Agent

A coding agent may not say "done" until a second, fresh gVisor sandbox on Vultr proves it. Catches skipped tests, masked exits, forged reports and hardcoded answers; logs every escape attempt.

Evidence Gated Agent

VULTR

SRE Incident Agent — Blast Radius Zero

Agentic SRE assistant: paste an incident log — an LLM plans and runs diagnostic snippets in a sealed Docker sandbox on Vultr, verifies the output, and returns findings, root-cause hypotheses, and an ordered runbook. Containment you can see.

SRE Incident Agent

VULTRDeepSeek V3rest api

Agent_Trap_Evals

The problem: agents rarely fail hard questions. They fail chores. They report "backup verified" because the log says success, while the archive is truncated. These false claims slip out during routine work, and a real shell makes them dangerous. What Receipts does: you give it a real task, like checking a backup or triaging a failing build. A control layer plans the work and runs every action in an isolated Vultr sandbox [gVisor pods on VKE]. The sandbox has no secrets, has time and memory caps, and is destroyed after each task. Every command's output, exit code, and files become a receipt. Before any claim reaches you, a verifier checks it against those receipts: did the agent check the layer that matters, or just the easy one? An unsupported claim is blocked and sent back to be verified, or reported as unverified. You get the answer together with its proof. Containment: [demo moment, e.g. the agent runs rm -rf / and the sandbox absorbs it; the host is untouched]. Measured: we score Receipts with agent-trap-evals, an open-source trap set we built before the hackathon from real agent incidents. Verifier off vs. on: [X/Y vs. X/Y caught], [n] false alarms on honest controls. For: platform and DevOps teams putting agents on operational work, where a confident false "done" costs more than a slow answer. Sandboxes like E2B contain actions but don't check claims. Eval tools score offline but don't stop a bad claim at runtime. Receipts does both, live. [Business model; next steps.] All LLM calls use Vultr Serverless Inference.

AITeCXO

AgentOpsAnthropic ClaudeAWS+11

QuantGate

A Vultr-powered AI agent that generates and runs verified Python kernels in disposable containers to test model quantization, detect exact data overlap, and block releases that exceed storage or accuracy limits.

WataruAkis

CodexVULTR

Containment-First Agent Runtime on Vultr

A web agent that plans a task, runs code and drives a real browser inside a per-task Docker sandbox on Vultr Cloud Compute. Every response returns the isolation flags it actually enforced, so the safety claim is measured, not asserted.

Arber Arifim

VULTR

Blast Radius Zero: sandboxed agent runtime

Plans a task, runs the generated Python in a throwaway gVisor container on a Vultr VM, then has an independent verifier audit every claim against the bytes the sandbox produced. Built-in lab re-runs 7 real attacks: 7/7 contained.

Blast Radius Zero (Solo)

VULTR

Trifecta Checker AI Safety Gate for Lethal Agents

Trifecta Checker is an AI safety gate that blocks Lethal Trifecta attacks - the dangerous combination of Private Data + Untrusted Content + External Communication that enables data theft via prompt injection. The problem: AI agents with tools like read_gmail, browse_web, and send_email can be tricked by malicious web content to steal private emails and exfiltrate them. This is called the Lethal Trifecta. Our solution: One API call - POST /api/check-trifecta - analyzes the agent's tool manifest and returns instant verdict: - LETHAL (3/3 tools): 403 Forbidden - BLOCKED - Cannot execute - WARNING (2/3 tools): 200 OK with caution flag - SAFE (1/3 tools): 200 OK - Safe to proceed Live and tested: https://trifecta-checker.vercel.app/ - LETHAL test [read_gmail, browse_web, send_email] -> 403 - WARNING [browse_web, send_email] -> 200 warning - SAFE [read_gmail] -> 200 safe For 【entity-AMD¦canonical_name=AMD】 AI League Match 4 - Intelligent Web Information Retrieval - we extend with Trusted Source Verification: before allowing external communication, we verify web sources are trusted (.gov, .edu, Concordium ID verified). If source is untrusted, block or flag. Tech: Next.js 14 + TypeScript, Vercel Edge, Python/JS SDKs, 【entity-AMD¦canonical_name=AMD】 ROCm ready for LLM inference. GitHub: github.com/altima261/trifecta-checker. Blog: dev.to/altima261. Built by Mohammed Binashwan (altima261) from Jeddah, Saudi Arabia. Team trifecta-checker solo UTC+3. This project also registered in Concordium Trusted Agents (ZK Proofs + on-chain audit) and Vultr Agent Rush (Blast Radius Zero sandbox).

trifecta-checker

VercelAMD ROCm

AMD Volta: Intelligent Web Retrieval Agent

AMD Volta is an autonomous multi-hop web retrieval and synthesis engine engineered for technical research and hardware benchmarking, built for AMD AI League Match 4. Key Innovations Solved: 1. Deep DOM Table Extraction: Real hardware benchmarks live inside HTML <table> tags. Standard text chunkers flatten them into noise. Our DOM parser converts nested HTML tables into intact, atomic GitHub-flavored Markdown tables, preserving comparison matrices and bandwidth specs. 2. Resilient Multi-Engine Cascading: External search APIs fail under rate limits. Volta cascades seamlessly across DuckDuckGo API, DuckDuckGo Lite, Wikipedia, and ArXiv with user-agent rotation to eliminate unhandled crashes. 3. Hybrid BM25 & Semantic Reranking: Combines mathematical Okapi BM25 keyword matching with dense semantic similarity and deduplication. 4. Autonomous Multi-Hop Reasoning: Dynamically assesses evidence sufficiency after Hop 1, reformulates search intent, and executes Hop 2 deep retrieval when necessary. 5. Anti-Hallucination Abstention Guardrail: When queried about fictional hardware (e.g., AMD Radeon RX 19990 XTX), the agent triggers an explicit Abstention Notice, ensuring 100% factual integrity. Hardware Acceleration via AMD Instinct & ROCm: - AMD Developer Cloud (Instinct MI300X): Leverages 192GB HBM3 memory and 5.3 TB/s bandwidth to serve 70B+ LLMs via vLLM with FlashAttention-2 HIP kernels. - Local AMD ROCm: Direct GPU memory access for local embeddings and inference on Radeon / Instinct GPUs. - Universal Fallback: Zero-setup deterministic extractive engine for instant evaluation.

Deflect

AMD Developer CloudAMD ROCmStreamlit+1

AI Evaluation Lab: Reliable Agents on AMD

AI Evaluation Lab is an independent engineering project focused on making AI agents easier to test, verify and improve. For the AMD AI League, I am developing a shared foundation for source-grounded information retrieval and test-verified code repair. The retrieval workflow is designed to extract specific answers from documents or websites, preserve the supporting sources, and return no answer when the available evidence is insufficient. The code-repair workflow will reproduce a failure, propose a focused patch, and check it against relevant tests before reporting the outcome. The planned implementation uses Python, open-source models and AMD ROCm, with Docker containers tailored to each match's requirements. Evaluation will cover answer correctness, citation accuracy, repair success, regression failures, latency and GPU memory use. Separate test cases will help check whether improvements generalize beyond the public examples. This solo entry builds on my work in AI evaluation, benchmark development and OmniEdge RouteIQ from AMD ACT II. The project is currently in development; AMD runtime validation and official challenge scores are pending.

AI Evaluation Lab

AMD ROCm

AMD ROCm Grounded Web Agent

GroundedROCm is a 100% ROCm-native grounded retrieval engine powered by Qwen2.5-0.5B on AMD MI300X delivering verified JSON answers with zero hallucinations. Traditional search suffers from CUDA dependencies, high latency, API costs, and hallucinations. We solve it with a 5-stage local pipeline: Planner (Qwen2.5-0.5B via http://llama.cpp with fast-path for simple queries), Search Layer (Tavily / Qdrant / JSONL pluggable), Evidence Engine (deduplication + BM25 + compression), Synthesizer (warm http://llama.cpp server with schema-constrained JSON, max 96 tokens), and Guardrails (JSON repair + number/name grounding + URL validation). Result: 15MB binary via http://llama.cpp, small Docker size, ∼0.6s latency on MI300X, 98% grounding accuracy, 100% source validity, zero CUDA, zero external cost, instantly switchable to internal Qdrant for enterprise deployment.

Seeno

AgentOpsQwen3AMD ROCm

NanoMesh: Local AI, Tuned to Your Hardware

NanoMesh is a Windows-first, local-first platform designed to make running AI models on personal computers simpler, smarter, and more accessible. It helps developers discover suitable models, understand hardware compatibility, and evaluate performance before committing their resources to a particular AI workload. Starting with GGUF models and llama.cpp, NanoMesh combines hardware-aware recommendations with runtime capability detection to help users determine which models are appropriate for their systems. Rather than relying solely on hardware specifications, the platform aims to distinguish verified runtime capabilities from estimates, helping users make more informed decisions about CPU and GPU execution. NanoMesh is being developed to support a practical local AI workflow: discover models, select suitable configurations, download with user approval, and benchmark performance. Its long-term goal is to compare important trade-offs, including inference speed, memory usage, stability, and task-specific model quality. AMD hardware is an important opportunity for this vision. By making runtime backends and hardware capabilities more transparent, NanoMesh aims to help developers explore local AI workloads on compatible AMD-powered systems and make better use of the computing resources they already own. The broader mission is to bring AI closer to users through efficient, hardware-aware, privacy-conscious local inference, reducing unnecessary dependence on cloud services while making experimentation more reproducible and accessible.

brass

Claude Code

GreYat Web Scout: grounded web retrieval

GreYat Web Scout is a Match 4 agent for intelligent web information retrieval. It takes a natural-language question, with an optional start URL, and returns one exact value together with the page it came from. How it works: a language model (Qwen3-4B-Instruct, served on the AMD GPU by a resident process so each query skips the load time) first plans the lookup: search queries, likely official URLs, and package or project names. In parallel the agent queries several search engines and Wikipedia, and for "latest version" questions it reads the authoritative registries directly (PyPI, npm, GitHub releases, endoflife.date). It fetches the best pages, keeps the passages that match the question, and asks the model to extract a single value and say which passage it came from. Grounding comes first. An answer is only returned if the value appears verbatim on the cited page, so the source URL always backs up the answer. If no page confirms it, the agent returns an empty answer instead of a guess, and answers to "latest" questions are never taken from the model's memory. Version strings and numbers are normalised (v-prefixes, LTS labels, thousands separators) to match the grader. Everything runs locally on AMD ROCm with no external API keys. In development, on a 30-question set covering facts, ports, people, dates and live package versions, the pipeline answered 26 correctly (tested with a hosted stand-in model, since GPU time was not available).

GreYat

AMD ROCmQwen3HuggingFace Hub

SourceCourt Exact Lite

SourceCourt Exact Lite is a bounded, evidence-first research assistant built for AMD AI League Match 4. It answers source-grounded questions while refusing to invent certainty when the available evidence does not support an exact answer. The system retrieves and parses bounded HTTP/HTTPS sources, interprets a user’s question, identifies relevant evidence, ranks candidate passages and links, and extracts an exact answer only when the evidence is sufficient. When the answer is ambiguous, unsupported, or unverifiable, SourceCourt refuses rather than fabricating a result. The project was hardened against unsafe retrieval behavior. Its transport layer rejects private and loopback network targets, protects against SSRF and DNS rebinding, preserves TLS hostname verification, limits redirects, constrains response size and timing, and avoids unsafe proxy behavior. It also includes bounded resource use, deterministic error handling, citation checks, and explicit ambiguity/refusal behavior. SourceCourt Exact Lite is packaged as a real command-line product. It can be installed as a Python package, run locally, or executed from a container image. The public release includes reproducible setup instructions, a deterministic demo, and a security-focused test suite. The release is provider-neutral at the model-adapter boundary, keeping retrieval, ranking, evidence extraction, citation, refusal, and safety logic independent from any single model provider while allowing the official Match 4 runtime or grader to supply the required model configuration. Container: `ghcr.io/null007void/sourcecourt-exact-lite:1.1.2` Digest: `sha256:39cd2d31e6fb95219da190d12a5620868e68293ac6ad88f8659142b744e4feec` SourceCourt Exact Lite returns the exact answer when the source supports it, shows the supporting evidence, and refuses when the result cannot be verified.

Null007Void Labs

rest apiCodexChatGPT+1

ROMA: Autonomous Exact Web Intelligence Agent

ROMA is a production-grade, deterministic autonomous web intelligence agent engineered specifically for the AMD AI League Match 4 (Intelligent Web Information Retrieval) challenge. Powered by the AMD ROCm ecosystem and open-source models, the agent navigates live web environments, retrieves specific normalized target values, and guarantees exact source URL attribution. Key Architecture: 1. Sub-Second Latency: Average query response time of 0.53s on benchmark evaluations, well within the 30-second budget. 2. Dual-Engine Architecture: Resident background daemon in VRAM communicating with an ultra-lightweight CLI client (/app/app.py) via local RPC. 3. Zero-API Key Dependency: Keyless retrieval aggregating DuckDuckGo, Wikipedia REST API, and direct registry endpoints (PyPI, npm). 4. Strict Cite-or-Refuse Verifier: Enforces literal substring containment against source text. Fictional or ungrounded queries cleanly return empty answers and empty citations, eliminating hallucination penalties. 5. AMD ROCm Certified: Packaged directly from the official rocm/pytorch base image with dependency isolation for AMD Instinct MI300X accelerators.

ROMA

AMD ROCm

ZeroNet-RAG - Offline Fail-Closed Agentic RAG

ZeroNet-RAG is a production-ready, highly secure, and fully offline agentic Retrieval-Augmented Generation (RAG) framework custom-engineered for the AMD AI League Match 3 challenge. Operating under strict air-gapped constraints (--network none), the framework completely eliminates external API dependencies and cloud network calls during runtime. At its core, ZeroNet-RAG utilizes a robust dual-engine search mechanism combining deterministic sparse feature hashing with BM25 lexical ranking to ensure ultra-fast corpus indexing and sub-second query retrieval. The multi-format document parsing pipeline seamlessly ingests PDFs, DOCX, spreadsheets, text logs, and images via optical character recognition (OCR), featuring resilient error-handling that gracefully handles edge cases. Powered by a state-based LangGraph orchestration workflow (incorporating Planner, Retriever, Extractive Generator, and Guardrail nodes), the system enforces a strict cite-or-refuse policy to eliminate hallucinations. If direct supporting evidence is absent from the local corpus, it securely returns a structured empty response complying with the required JSON output contract (answer and citations). Fully containerized using an optimized lightweight Python environment, ZeroNet-RAG guarantees deterministic execution, strict data privacy, and robust performance under rigorous latency limits.

hadix_gang

AIMLAI/ML APIAgentOps

SentinelMesh: Autonomous AI SOC on AMD GPU

SentinelMesh is an enterprise-grade, autonomous multi-agent AI Security Operations Center (SOC) purpose-built for on-premise execution on AMD Instinct GPUs using ROCm 6.2 and vLLM. Traditional SOCs struggle with catastrophic alert fatigue, high mean-time-to-respond (MTTR), and cloud API privacy risks. SentinelMesh solves this by deploying a collaborative team of specialized autonomous AI agents that detect, investigate, contain, and report cyber threats in seconds with 100% data sovereignty. Architecture & Multi-Agent Pipeline: 1. Triage Agent: Evaluates heterogeneous telemetry (Linux auth, Nginx, Windows Security Events) against in-memory sliding-window rules, filtering noise with high confidence. 2. Investigator Agent: Reconstructs causal kill-chain attack graphs, identifies affected assets, and maps adversary tactics to MITRE ATT&CK techniques via local vector RAG. 3. Threat Intel Agent: Assesses IOCs against local threat feeds with automated abuse scoring. 4. Responder Agent: Formulates surgical containment actions (IP firewall blocks, account lockouts) guarded by a Human-in-the-Loop approval gate with automated rollback commands. 5. Reporter Agent: Synthesizes bilingual executive briefings in technical English and native Urdu (Nastaliq RTL) with WeasyPrint PDF export. AMD ROCm Hardware Synergy: Accelerated by AMD Instinct MI250X (128GB HBM2e) with ROCm 6.2 and vLLM PagedAttention, SentinelMesh delivers 138.5 tokens/sec throughput, 42ms TTFT latency, and a 79.5% operational cost reduction compared to commercial cloud APIs. Telemetry never leaves the enterprise boundary.

I CAN

AMD ROCmLLaMA

PrintLoop

PrintLoop reads photos of a failed 3D print, finds the slicer setting that caused the defect and proposes a minimal preset fix, verified in the G-code before reprinting and applied only with the operator’s approval.

Agentic era

AMD Developer CloudAMD ROCmGemma

FlowCast

Cleanrooms and control cabinets run fans at worst case because predicting a lower setting takes a CFD study. Flowcast learns from 7,500 airflow simulations to find the lowest safe setting in seconds, on AMD GPUs, and confirms it by simulation.

FlowCast

AMD ROCmClaude CodeGemma

NumeriGuard

Core product: Run reference problems across versions and devices; check physical invariants, convergence behavior, output tolerances, and performance.

Solosquard

AMD Developer CloudAMD ROCmLLM Gateway

EduGuard Agent

AI security for educational data protection Detects risky access to student records, explains why it matters and lets administrators decide what happens next

SentrX

AMD Developer Cloud

Scenaria from evidences

An experinmental tool to get testable scenarios from business evidences (documents) with strong provacy enforcement

PaperPlane

Anthropic ClaudeToken Factory

DeepAudit AMD: AI Code & ROCm Security Auditor

Autonomous code security, PyTorch VRAM leak remediation, and ROCm 6.3 kernel optimization powered by AMD Token Factory and Google Gemma-4-31B-IT with $8,400 measurable downtime prevention ROI and cryptographic Human-in-the-Loop audit sign-off.

Sahariar-Dev

GemmaAMD ROCmAntigravity+2

MachineMind: Predictive Maintenance Assistant

Intelligent industrial rotating machinery monitoring combining unsupervised anomaly detection, root-cause attribution, prescriptive LOTO checklists, and AMD hardware-accelerated inference.

Sanguinius

StreamlitAMD ROCmAnthropic Claude+2

30apps loaded