amd Applications

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

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

Trifecta Checker - Blast Radius Zero

AI Safety Gate that blocks Lethal Trifecta (Private+Untrusted+External=403) and prevents Vultr VM spawn if agent is malicious. Blast Radius Zero on Vultr Cloud.

Trifecta Checker

VercelAMD ROCm

SAAS Fashion Garment Marketing Digital Control

Prototype SAAS SCM V4 for Indonesian fashion garment SMEs - from Batik design, Yard/Kodi control, Sritex invoice to digital marketing. AI trend forecasting, OEE 95%, ERP, KPI on Vultr Serverless Inference + AMD MI300X for cultural fashion agenda.

SuperInfra Trinity V32-2

AMD ROCmAMD Developer CloudLLaMA+3

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

ROCm Plate & Sign OCR (AMD AI League)

An OCR container for AMD AI League Match 2 that reads licence plates and road signs with an open vision-language model running on an AMD GPU through ROCm. How it works: the container starts a resident server that loads Qwen2.5-VL-7B-Instruct once, in bf16 on the GPU, runs a warm-up inference and then listens on a unix socket. Each call to app.py is a thin client, so the harness can start a new process per image without the model ever being reloaded. Image handling accepts PNG, JPEG and TIFF (including 16-bit and multi-page files), applies EXIF rotation, and resizes very large or very small images to keep the number of visual tokens, and the time per image, bounded. The prompt encodes the transcription rules: return the plate number without state names or slogans, keep the province character and letter on Chinese plates, keep every word printed on a sign, and join multi-line text top to bottom. Post-processing removes labels, quotes and explanations, and folds look-alike separators and full-width characters that the grader's normalization would not remove. Reliability: the model weights are baked into the image, so it runs with no network access. Every call writes a valid JSON file, even when something fails. The build checks that torch and torchvision are ROCm builds. The image is built and contract-checked in GitHub Actions, and evaluated against the sample images plus blurred, noisy, glare, low-light and skewed variants.

Clevermiss

AMD ROCmHuggingFace HubQwen3-Coder

Veriweb: Research You Can Trace

Veriweb helps researchers compare information across the web without losing the evidence behind an answer. A user enters a research question, and Veriweb breaks it into focused searches, extracts full article text, and combines BM25 keyword ranking with vector embeddings to retain relevant passages. The report presents requested comparisons with clickable citations that open the exact supporting quotation beside the answer. Its conflict matrix pairs differing figures with their original passages, helping users distinguish genuine disagreements from differences in dates, units, or scope. Missing evidence remains visible, and unsupported questions can produce an explicit abstention. Citations establish provenance rather than automatically certifying a source as correct. Built and demonstrated on an AMD Ryzen 5 5600H and Radeon RX 6500M with 4GB VRAM, Veriweb runs quantized Qwen2.5-3B locally through Vulkan. Standalone generation measured 36.7 tokens per second. ROCm PyTorch computation was verified separately. The project includes a Next.js research dashboard, FastAPI backend, attributed Markdown export, and a bounded CLI that writes structured JSON. All 40 controlled synthetic research cases passed in the latest complete evaluation. These results are regression evidence, not a claim of universal live-web accuracy.

Vyapai

AMD ROCm

Ariadne

Ariadne is a production-grade, proof-grounded web information retrieval agent. Most LLM-based web agents suffer from a critical flaw: they hallucinate. When they cannot find an answer, they guess, leaving users with confident but fabricated lies. Ariadne solves this using a strict "Proof or Silence" architecture. When given a starting URL and a natural language question, Ariadne navigates the website using information-scent scoring. It extracts candidate answers using a three-tier pipeline: deterministic schema.org JSON-LD parsing, LLM-based reading comprehension (via the Gemini API), and a conservative rule-based fallback. Crucially, Ariadne is built with generator-verifier separation. The LLM that extracts the answer is never allowed to declare it correct. An independent Verifier enforces a strict verbatim-quote gate (the quote must exist exactly in the fetched HTML), an attribute-attachment gate, and an independent entailment check. If any gate fails, the agent explicitly returns "not_found". Every successful query returns a "proof object" containing the answer, the exact source quote, the URL, and a SHA-256 content hash, ensuring 100% auditability. If no proof exists, it refuses to guess. Engineered for hostile web environments, Ariadne includes SSRF guards to block private IP fetching, NFC Unicode normalization for international text matching, and strict body-size limits to prevent DOM/resource exhaustion. Packaged on the mandated ROCm base image, Ariadne leverages GPU-accelerated inference via Gemini, ensuring rapid, deterministic, and hallucination-free retrieval that enterprise applications can actually trust.

Deterministic Doom

Gemini AIAMD ROCmAMD Developer Cloud+1

Banksy OCR: Plates & Road Signs on ROCm

Banksy OCR is a containerized optical character recognition application for Mini-Challenge 2 that reads license plates and road signs using an open-source vision-language model running on AMD GPUs through ROCm. Architecture: when the container starts, a persistent server loads Qwen2.5-VL-7B-Instruct (bf16, weights baked into the image) onto the GPU once and runs a warm-up pass. The harness entrypoint, python3 /app/app.py --input-image <path>, is a thin client that sends the image to that resident model, so each call avoids reloading weights. A task-specific prompt encodes the transcription rules (drop state names and slogans on US plates, keep the province character and letter on Chinese plates, keep words printed on signs, join multi-line signs top to bottom, never add units), and deterministic post-processing strips labels, quotes, unit suffixes and leftover jurisdiction banners before writing /app/output/<name>_output.json with text and confidence. Inputs: PNG, JPEG and TIFF (first frame), any size; very large images are downscaled before inference. Validation: built FROM the mandated rocm/pytorch rocm10.0 / Ubuntu 26.04 / Python 3.14 / PyTorch 2.13 base without squashing (all base layers verified intact). Tested inside the final container on an AMD Radeon 8060S (ROCm 10.0, torch 2.13.0): 31.2 GiB image, 23 s startup, 0.7-2.5 s per image, about 16.5 GiB peak GPU memory, 10/10 on a synthetic set covering clean, angled, blurred, low-light, noisy and multi-line cases. The same code was also run on an MI300X in the AMD notebook environment.

Banksy

AMD 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

Aperture - Web Retrieval with Traceable Evidence

Aperture is an AI web retrieval agent built for AMD AI League Match 4. It accepts a natural-language question and an optional starting URL, navigates web pages, and returns a concise answer with supporting source URLs. The system combines asynchronous retrieval, structure-preserving parsing, and a locally hosted Qwen3-4B-Instruct-2507 model. It preserves headings, tables, and labeled fields so that names, dates, versions, and numeric values retain their context. Evidence checks verify literal support, source provenance, answer types, and requested qualifiers. When available evidence is insufficient, the agent returns an empty answer. Inference runs locally, and retrieval uses no paid search service or remote inference API. The submission is packaged as a prebuilt Docker image using the required ROCm base, with model weights included. Local validation covers extraction, output formatting, runtime behavior, and factual retrieval. General web accuracy remains limited by search availability, page access, model errors, and time budgets. AMD GPU execution and official evaluator acceptance have not yet been verified. The public repository includes implementation details, benchmark reports, and reproducibility documentation.

Aperture

Qwen3AMD ROCm

Exact Web Answer Agent (AMD AI League Match 4)

Match 4 entry: an agent that reads a natural-language request, navigates the given website (or a saved copy of it) and returns the one specific value the user asked for, with the page it came from. Not a summary and not a list of links. Match 4 image: docker.io/driedsandwich/amd-ai-league:m4-v1 How it works. Each request runs as a fresh python3 /app/app.py process with a 24-second internal deadline. It writes a well-formed placeholder JSON first, then fetches the start page with short timeouts, follows the same-site links whose text best matches the question, cleans each page to text (tables kept as rows) and ranks passages. A Qwen3-4B-Instruct model, loaded once at container start and kept resident on the AMD GPU behind a unix socket, picks the value from the top passages and names the supporting page. A rule-based extractor for prices, dates, versions, numbers and contacts is the fallback when the model has no time left. The answer is the value only; if the pages do not contain it, the agent returns an empty answer instead of guessing. Output: /app/output/<query-id>_output.json with answer, citations (source URLs, or corpus-relative paths when pages are given as a folder), sources, source_url and confidence. Because the detailed Match 4 harness was not published, the image follows the container contract shared by the earlier Matches: the mandated ROCm PyTorch base image, weights shipped inside the image, no downloads at start-up, and the model placed on the GPU explicitly. The script accepts several argument spellings (--query or --question, --query-id or --id, --url, --corpus for saved pages, --index, --input). No API keys; inference runs locally on the AMD GPU. Match 3 and Match 2 images are given in their Mini Challenge fields (docker.io/driedsandwich/amd-ai-league:mc3-v1 and docker.io/driedsandwich/amd-ai-league:mc2-v2).

DriedSandwich

AMD ROCmQwen3Qwen3-VL

WaltTrace — Offline Multimodal RAG

WaltTrace answers short factual questions from mixed engineering documents while returning the exact files needed to support each answer. It parses PDF, Word, Excel, CSV, logs and source files, and uses a local vision-language model to read diagrams, scanned pages and equipment labels. Retrieval follows identifiers between incident reports and lookup tables, allowing answers that require more than one document. Generated quotations are checked against indexed source text; unsupported answers are refused with an empty answer and citation list. Qwen2.5-VL-7B runs on a real AMD GPU through ROCm PyTorch. All weights are embedded in the mandated container base, and the application runs without outbound network access. Indexing starts a resident model behind a private Unix socket so each fresh question process avoids reloading the weights. Malformed, unreadable, encrypted and unsupported files are skipped independently. The development report documents actual GPU timings, memory readings, individual answers and citation checks. Public-sample results are development evidence, not a claim about hidden evaluation scores or League points already awarded.

WaltTeam

AMD ROCmHuggingFace Hub

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

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

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

AEGIS

AEGIS – Short Version AEGIS is a low-cost autonomous ground rover for border and field patrolling, target navigation, surveillance, and operation in GNSS-denied environments. Built on ROS 2 and Nav2, it supports GPS-based target navigation and multi-waypoint autonomous patrol missions. When GPS becomes unreliable, AEGIS switches to local navigation using odometry, inertial sensors, visual odometry, and pre-built maps, enabling continued patrol without satellite positioning. Its camera-based perception system uses YOLOv8 to detect drone-like aerial targets, people, and predefined human activities, generating operator alerts for suspicious events. It does not identify individuals or infer intent. The rover uses a rechargeable battery with solar-tracking support for longer field endurance. A modular, regulated RF counter-UAS research module is included for authorized defence/testing environments, focusing on GNSS-degradation detection rather than operational jamming. AEGIS is intended as a safe, modular technology demonstrator for perimeter security, disaster response, infrastructure monitoring, and search-and-rescue missions, reducing human exposure in hazardous areas..

TEAM AEGIS

AI/ML APIAntigravityAMD Developer Cloud+5

ChronosGraph: Temporal Web Verification Engine

ChronosGraph is a temporal web information retrieval and verification engine for AMD AI League Match 4. It answers a natural-language question by navigating seed pages and their links, within a 6-page and 2-hop budget, extracting claims from specification tables, JSON-LD and body text, and scoring them by relevance, freshness and version. When a stale 2023 page conflicts with a 2026 specification, the newer authoritative row wins, and the answer is always a verbatim quote with a citation and a SHA-256 evidence receipt. If no source contains verifiable evidence, it refuses instead of hallucinating. The public demo shows this clearly: Mode 1 resolves 128 GB versus 192 GB HBM3 and 5.3 TB/s, Mode 2 resolves $4.50 versus $2.85 per hour, and Mode 3 refuses a fictional Quantum Flux Toaster 9000. A short exact answer, such as $2.85, is shown separately from the full quote, with a citations list that is empty on refusal. Understand uses synonym groups, so throughput, fee, RAM and cost are matched to bandwidth, rate, memory and price. The engine was verified in an AMD notebook on ROCm, with 16 tests passed and a 6/6 benchmark, and the public demo runs on CPU with zero paid API keys.

ChronosGraph ROCm

StreamlitAMD ROCm

Käyrä - identify undocumented

Käyrä works out what an undocumented controller does from data a site already logs. A language model on AMD writes hypotheses as small programs with no numbers; a fitter finds every value and decides. Tested live on a real heating plant.

APN201

AMD Developer CloudAMD ROCm

ForgeMind AI

ForgeMind AI is an industrial IoT telemetry & autonomous diagnostics platform engineered for mission-critical edge equipment. Leveraging high-throughput inference on AMD hardware, ForgeMind continuously monitors vibration (ISO 10816-3).

Project Hail Mary

AMD Developer CloudAMD ROCm

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

AMD-OmniSight: Edge Vision & Telemetry Agent

Problem: In high-stress aerospace and deep-space missions, detecting structural anomalies, cryogenic leaks, and thermal fractures in rocket engines (such as turbopump vibrations and De Laval nozzle walls) requires sub-5ms real-time processing. Cloud-dependent vision pipelines suffer from extreme telemetry latency and bandwidth constraints. Solution: AMD-OmniSight is an ultra-fast, autonomous multimodal edge intelligence agent engineered for AMD Instinct (MI300X/MI250) and Radeon RX 7900 accelerators using AMD ROCm 6.2 and HIP kernels. By utilizing vectorized half-precision (FP16/BF16) tensor operations, OmniSight processes 230+ FPS with an unprecedented 4.19ms inference latency. Key Capabilities: 1. Native AMD ROCm Acceleration: Vectorized FP16 matrix operations and custom kernel acceleration. 2. Real-Time Anomaly Localization: Micro-fracture, cryogenic leakage, and thermal hotspot detection. 3. Edge Telemetry REST API: Fast asynchronous telemetry streaming via FastAPI and interactive HUD dashboard. 4. Compute Efficiency: Exceptional 9.4 FPS/Watt compute efficiency on enterprise AMD silicon. Target Audience & Impact: Space agencies, aerospace manufacturers, satellite operators, and mission-critical industrial robotics teams requiring sub-5ms deterministic edge inference.

AMD-OmniSight

AMD ROCmAMD Developer Cloud

WebScout Exact: Match 4 Retrieval Agent

WebScout Exact is my entry for Match 4 of the AMD AI League (Intelligent Web Information Retrieval). The agent takes a natural-language question, optionally with a starting URL, and returns one exact value plus the source page it came from, not a summary or a list of links. It runs as a single Docker container built on the official ROCm PyTorch image, so it works on AMD Instinct GPUs. Pipeline: the question is classified into an answer type (number, date, version, price, name, phone and so on); the agent fetches the given URL or searches the web, follows the most relevant links, and cleans each page into plain text. Candidate values are extracted with rules for each answer type and checked by a local Qwen3-4B-Instruct model served from the container on the AMD GPU, which picks the value that best matches the question. The answer is normalised the way the grader compares answers and written to a JSON file with the answer, source URL and confidence. If the model is not available, a rule-based path still answers. Each query is designed to finish well under 30 seconds and the model loads during the startup window. On my own held-out test set it answers 7 of 8 questions correctly. No API keys are used: all reasoning runs locally on AMD hardware. Image: ghcr.io/solar-depin-hub/amd-match4-agent:v1

Vadym Bilobrovets

AMD Developer CloudAMD ROCmQwen3+1

Forma: AI-Powered Virtual Fitting

Forma is an AI-Powered Virtual Fitting designed to revolutionize the online shopping experience. By combining virtual try-on technology with predictive data analytics, it bridges the gap between digital retail and physical confidence

Gitogether

AMD Developer CloudDeepSeek V3Gemini AI

RepeatFix

RepeatFix finds repeat failures hidden in messy aircraft maintenance logs and helps technicians fix the next breakdown faster, using past fixes and cited FAA procedures. Running on AMD GPUs via AMD Token Factory.

RepeatFix

AMD Developer CloudDeepSeek V3

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

LedgerHawk

LedgerHawk reviews supplier PDF invoices with three Evolus workflows and deterministic AP controls. It flags duplicates, changed bank details, and PO mismatches, then records a decision or sends the case to human review.

HereForTheFood

AMD ROCmAMD Developer Cloud

Kagban - A factory-based learning environment

A factory-based learning environment to teach concepts in Kanban-based factory optimisation and reinforcement learning.

Conclave Industries

AMD ROCmAMD Developer Cloud

Berkelium Neural Rendering Studio

Berkelium Studio turns plain-language engineering requests into exact, validated CAD models and renders them as real-time Gaussian splats, all in one open desktop app powered by models fine-tuned on AMD.

Berkelium

AMD Developer CloudAMD ROCmAnthropic Claude+1

Auditing Dynamic Routing on AMD MI300X

We reproduced a 2025 adverse-weather detection paper on AMD MI300X and measured its core mechanism: the "dynamic" router outputs near-uniform weights for every image (entropy 0.9998/1.0). It costs +41% latency for no mAP gain.

TARS

AMD ROCm

30apps loaded