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.

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

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

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

Financial Fact Reconciliation in 1 LLM Call

Conflicting headlines about the same company are often both true: "Intel lost $0.38" (GAAP) and "Intel earned $0.02" (non-GAAP) both quote Intel. Reconciling them with LLMs is expensive and error-prone — an agentic loop burns 5 calls and 46k tokens yet still merges the two figures into a half-truth. This submission solves the problem the other way around: almost everything happens in a deterministic discriminative pipeline (filter → rank → reconcile → guard) that costs about 7 ms and uses zero LLM calls; the LLM is called exactly once, on 2-3 already-validated sources, to produce a reconciled answer with citations — or to refuse when the evidence is insufficient. Measured on a 10-case real-world financial corpus (53 snippets, every URL verified): 1 call and 1,572 tokens in 440 ms vs 5 calls and 46,563 tokens in 30.5 s for the agentic baseline (−96.6% tokens, 69.5× faster). The gate drops 64% of the pool before any LLM call, and a confidence guard makes the generator refuse (INSUFFICIENT) when no primary source supports the winning claim. All numbers are generated from run.json, never hand-written, and protected by a 17-check gate with 77 unit tests.

TruthForge

LLaMA

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

Web Retrieval Agent: Answers With Proof

Web Retrieval Agent is an AI agent that takes a plain-English question, searches the live web, reads the actual pages and returns only the specific information the user asked for, together with the exact quote that proves it. Most AI search tools write a fluent answer and ask you to trust it. This agent treats the language model as untrusted. It plans targeted search queries, uses Tavily to search and extract full page text, and asks the LLM (gpt-oss-120b on Groq) for a structured answer with verbatim evidence quotes. The server then checks every quote against the real page text and drops any that do not appear. If the answer contains a figure that the quotes do not support, confidence is lowered and the user is warned. If the sources do not contain the answer, the agent says so instead of guessing, and it can retry once with refined queries focused on a likely site. The interface streams the agent's activity live (planning, searching, reading, verifying), then shows the answer, a confidence meter, the proof quotes with source links and every source checked. It is built with Next.js and TypeScript and deployed on Vercel. The LLM client works with any OpenAI-compatible endpoint, so the model can be swapped for an open model served on AMD GPUs.

Xdaid

AI/ML APIAnthropic ClaudeAntigravity+2

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

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

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

WebScout AI

WebScout AI — Evidence-First Intelligent Web Retrieval Agent WebScout AI is an agentic web research system built for the AMD AI League Match 4: Intelligent Web Information Retrieval. It transforms natural-language queries into structured research workflows, retrieves multi-source information, verifies evidence, and generates concise answers with traceable citations. The Problem Traditional AI assistants often generate convincing answers without reliable grounding. Researching across fragmented, complex, or deeply navigated web pages makes finding accurate facts challenging. Users require transparency and verified evidence over unsupported AI output. Our Solution WebScout AI leverages LangGraph to orchestrate an end-to-end pipeline: query analysis, source discovery, navigation, content extraction, evidence ranking, verification, and answer generation. TinyFish handles web search and retrieval, while configurable LLM providers (OpenRouter, Gemini, NVIDIA-compatible APIs) execute structured extraction. Key Capabilities Agentic Execution: Natural-language research with bounded agent steps. Smart Web Discovery: Web search and deep navigation powered by TinyFish. Evidence Verification: Ranks evidence and verifies exact-source quotations. Traceable Citations: Generates answers linked directly to sources. Conflict & Hallucination Guardrails: Detects unsupported claims and safely abstains when evidence is missing. Flexible Configuration: Supports customizable LLMs, timeouts, and resource limits. Production Ready: FastAPI backend, lightweight frontend, and Docker containerization. Technical Stack & Validation Built with Python, FastAPI, LangGraph, LangChain, TinyFish, Pydantic, and Docker. Its architecture strictly separates retrieval from verification to minimize hallucinations. The system passed 64 automated tests and 26 offline evaluation cases, successfully demonstrating live end-to-end research via TinyFish.

Abdullah Usman

LangChain

Pinpoint: exact web answers with their source

Pinpoint is a web retrieval agent built for AMD AI League Match 4. You ask for one specific piece of information in plain English, optionally with a page to start from, and it returns the value itself plus the URL of the page it was read from. When none of the pages it opened contains the value, the answer stays empty. The agent searches with keyless providers (DuckDuckGo, Bing, the Wikipedia API) or starts from the given URL, opens the pages and the links whose anchor text matches the request, and turns each page into clean text: navigation and citation footers removed, table rows kept together, JSON API responses flattened to field: value lines. The best passages go to Qwen2.5-7B-Instruct, which stays resident on the AMD GPU and replies with JSON: the value, the passages it used, an exact quote and an optional link to open next. Code then checks that the value really occurs in the cited passage. If it does not, the answer is dropped and the agent follows the suggested link, up to three read rounds inside a 24-second budget. Measured on an AMD Radeon Pro W7900D in the League notebook pool, inside the mandated ROCm 10 / PyTorch 2.13 / Python 3.14 image: 11 of 15 questions correct, 7.9 s mean and 16.1 s max per request in a fresh process, 15 GiB VRAM peak. The container follows the League contract (python3 /app/app.py, one JSON file per question in /app/output) and adds a single layer on top of the unmodified base layers. MIT licensed.

Innova Ottawa

AMD ROCm

Grounded Web Retriever

Ask a question in plain English and the agent returns one exact value plus the page it came from: a phone number, a release version, the name of a current office holder. The rule that shapes everything else: an answer is only returned if it appears on a page the agent actually fetched. A value the model remembers but cannot find on the web is thrown away. Each question gets two model calls. First, Qwen3-4B-Instruct plans the search: the answer type, the entity, two queries. Then keyless search (Brave, DuckDuckGo and Seznam, with Bing as a fallback) runs alongside a Wikidata lookup of the entity's official website. "Latest version" questions also go straight to endoflife.date, PyPI, npm and the project's own GitHub releases. The agent fetches the top pages, puts the official domain first, and follows contact or release links one hop. Typed extractors pull candidate values from text, tel: links and JSON-LD. The second model call reads the best excerpts and picks a value. The code then checks every candidate against the fetched pages and scores it by source, official domain, nearby question words and agreement between independent sites. Confidence is computed, not generated. On 16 held-out questions (software versions, official phone numbers, current CEOs, answers checked by hand), the agent answered 11 correctly. The same model with no web access answered 0: outdated versions, invented phone numbers. Those numbers come from Qwen3-1.7B on a laptop GPU; the 4B model in the container has not been measured yet, and nothing has been measured on AMD hardware. The container is built on the mandated ROCm base and keeps the model resident in a local server, so each per-question process is a thin client. No API keys anywhere. Mini Challenge 4 Image: the submission form has no Mini Challenge 4 Image field yet, so the image is listed here: ghcr.io/stuartyo/amd-match4:latest (public).

StuartYo

AMD ROCmQwen3HuggingFace Hub

Local OCR and RAG on AMD ROCm

This project contains my submissions for Mini-Challenge 2 (OCR) and Mini-Challenge 3 (RAG) of the AMD AI League. Both run in Docker images built on the mandated ROCm PyTorch base image, with the model weights shipped inside the image, so no network access is needed at evaluation time. Both solutions share the same architecture: a long-running FastAPI server, started by the container, keeps Qwen3-VL-2B-Instruct loaded on the GPU, and app.py is a thin client that the harness calls once per image or question. The model is never reloaded between calls. For OCR, a short English prompt with few-shot examples reads licence plates and road signs, with an automatic denoising and contrast step for dark images. For RAG, a single indexing pass converts every file type (PDF, Word, Excel, CSV, text, logs, Python, and images through the vision model) into text, skipping unreadable, encrypted and unknown files without stopping. Retrieval uses IDF weighting, a filename bonus and rare-identifier links for multi-hop questions. Citations and refusals are enforced by code rather than left to the model: the answer must appear in a cited file, every number or identifier in the question must appear in the sources, withdrawn revisions are excluded, and a linked file is cited only when the question does not already provide its identifier.

Kerdosmedia

AMD ROCmAMD Developer CloudHuggingFace Hub+1

SupplyWatch — Quote-Verified Supply Monitoring

Supply-chain change monitoring where every alert value is verified against an exact quote from the source page — no quote, no field. LLM-drafted alerts run on AMD ROCm; the pipeline is stdlib Python.

Kaminari Research

AMD ROCmAMD Developer CloudQwen3+1

GENVEY=gamified surveys

Transforms open-ended survey intent and corporate goals into interactive 3D/2D games using Gemma 4 on AMD Token Factory. Players make real in-game choices in WebGL and Godot 4, yielding System-1 conviction telemetry with zero local VRAM.

EdgeHackers

ChromaGemmaToken Factory

Trycanari

AI agents now do real things, move money, read private data, call tools. The problem is they can be prompt-injected: tricked by cleverly worded text into doing something they were told never to do. Real wallets have been drained this way.

ATTENTION IS ALL YOU NEED

AIMLAgentOpsAI/ML API+1

Source Trail

Source Trail makes web answers inspectable. Ask a natural-language question, supply starting URLs and optionally a software version, then review the answer beside exact quotes, source links, detected versions and a navigation trace. The Python prototype reads static HTML and plain text within a six-page budget. It ranks passages, preserves table context and checks every quoted passage against retrieved text. Verified mode adds version and current/stale-source signals; the baseline shares traversal, prompt limits and quote checks. Missing evidence can produce an abstention, while unresolved conflicting evidence can produce a conflict result. A local browser inspector and JSON export make the evidence easy to review. We validated Source Trail on an AMD Instinct MI300X virtual function through AMD's general One-Click Tutorial service, using local vLLM and pinned Qwen3-4B-Instruct-2507 weights. All 44 recorded model requests completed. Provider usage and server counters agree at 58,604 input and 2,335 output tokens, with active GPU samples overlapping every request. A fresh Python TaskGroup query returned an exact quote retaining the asyncio.CancelledError exception qualifier. On 16 fictional development cases, baseline scored 12/16 and verified scored 11/16. Both passed all six synthetic stress-development cases, and 114 unit and loopback tests passed. All failures remain available in the public repository; the fixtures are not held out or an official score. Quote presence checks text integrity, not answer entailment. Official Match 4 interface, evaluator and entry-container validation remain pending. The MIT-licensed source, runtime records and retained results let reviewers inspect this particular AMD development run. A separate online extractive demo uses Qwen3 0.6B to select one source passage verbatim within a three-page budget; it does not replay AMD responses.

Ammann Labs

AMD ROCmQwen3

Intelligent-Web-Information-Retrieval

A web retrieval agent that navigates links and GET forms, renders JavaScript with Scrapling, reads tables and PDFs, resolves conflicting evidence, and answers with verified citations. The latest agent workflow uses the local Qwen model from checkpoint 5 through a resident Transformers server. No ChatGPT login or hosted LLM API is needed. The model is Qwen/Qwen3-4B-Instruct-2507 with Transformers 5.20.2, BF16 weights, SDPA attention, deterministic generation and a 128-token output cap. These match the checkpoint's model configuration. The HTTP server keeps the model loaded between CLI queries; the agent's planning, extraction and review prompts are from the newer project. Features: - Navigate on the starting website, follow relevant links and submit discovered GET search forms. - Extract structured text from HTML and tables; render sparse JavaScript pages with Scrapling Chromium. - Read selectable-text PDFs and cite their page numbers. - Validate source passages, review meaning, handle competing claims and abstain when evidence is insufficient. - Run 33 local and public-site evaluation cases with traces and reports.

Ahmed Sa3ed

AMD ROCmAMD Developer CloudHuggingFace Hub+1

WebRetriever — Deterministic Web Retrieval Agent

WebRetriever is an autonomous web information retrieval agent built for AMD AI League Match 4: Intelligent Web Information Retrieval. Ask in plain English and get back the specific information you asked for, with the exact source URLs behind it — or an honest refusal when no verifiable answer exists. How it works — five-stage pipeline with a deterministic core: Understand — parses the request into intent (price, contact, hours, spec, definition, how-to, date, fact), entities, and 2–4 search query variants. No ML model required. Search — provider chain with automatic fallback: TinyFish Search for the best quality (JS-aware), and DuckDuckGo HTML as the keyless fallback with no signup needed. Fetch + navigate — fetches top hits, then follows promising in-page links within a fixed budget (8 pages, 2 hops) when the answer looks like it is one click deeper. Extract — structure-aware parsing: JSON-LD (Product, Organization, FAQPage), HTML tables such as spec sheets, intent-specific patterns for prices, phone numbers, emails, hours and dates, plus ranked text spans. Verify — every candidate is checked against its own source text; independent multi-source agreement boosts confidence. If nothing is supported by evidence, the agent refuses instead of guessing. The core pipeline uses no LLM, so results are reproducible and cheap. Citations are mandatory, and the agent runs on the free tier with no paid APIs. MIT licensed and Docker-ready, with 12 unit tests.

ArcOmega

rest api

WebScout ROCm

WebScout is an advanced, high-efficiency autonomous web information retrieval engine built specifically to harness the massive parallel processing power of AMD ROCm hardware. Designed for modern AI agents and knowledge workers, WebScout delivers lightning-fast web scraping, DOM parsing, and vector embedding generation. By leveraging AMD ROCm and ROCm-accelerated local LLMs, WebScout processes millions of web tokens with minimal latency, ensuring robust data extraction, semantic search, and structured knowledge synthesis. Key features include intelligent adaptive rate limiting, automated anti-bot avoidance strategies, robust proxy rotation, DOM distillation to remove boilerplate clutter, and real-time vector embedding indexing directly on AMD Radeon and Instinct GPUs using PyTorch and ROCm hipBLAS. WebScout empowers autonomous agents to query live web data securely, efficiently, and at scale without relying on expensive commercial APIs.

AMD AI Innovators

AMD ROCm

Student Insurance Navigator

AI health insurance advisor for US college students. Can help to estimate cost, choose insurance, and save money.

Interstellar

Anthropic ClaudeCodexAMD ROCm+3

IWIR(Intelligent-Web-Information-Retrieval)

Intelligent Web Information Retrieval Agent AKA IWIR is a high-precision, autonomous web intelligence and retrieval system engineered for Match 4 of the AMD AI League (Lablab AI Academy Challenge). Designed to operate under strict enterprise evaluation contracts, the system autonomously understands natural-language inquiries, navigates web ecosystems, and extracts exact, verifiable answers with zero hallucinations. The architecture is built around a rigorous 5-stage deterministic agent pipeline: 1. Understand: Performs semantic intent classification, entity boundary recognition, and multi-angle query reformulation. 2. Search: Executes keyless, resilient multi-provider search with automatic fallback mechanisms. 3. Fetch & Navigate: Asynchronously crawls target pages via aiohttp with redirect resolution, polite rate-limiting, and deep link-hopping. 4. Extract: Parses complex representations including JSON-LD schema graphs, HTML tables, and semantic content blocks. 5. Verify (Mandatory Contract): Validates candidate answers against source page token boundaries using strict regex validation before emission. If factual grounding cannot be proven, the agent produces an explicit refusal with zero citations, ensuring 100% precision. Optimized for AMD Developer Cloud instances (such as MI300X accelerators) and local developer environments, the solution is packaged in reproducible, production-grade Docker containers based on official AMD ROCm PyTorch distributions without any proprietary CUDA dependencies. It adheres strictly to headless grader contracts, sub-30-second query execution budgets, and full offline fallback validation.

void

AMD ROCmAMD Developer Cloud

Smart Agriculture Assistant

Tell the farmer what to plant, when to plant it, how to manage it, and when/where to sell it.

SoloStack

AI/ML APIAntigravityChatGPT+2

Voxely – Voice-Controlled Assistant

Voxely is a real-time voice assistant powered by AssemblyAI that converts speech to text, understands natural commands, searches the web, opens websites, and performs browser actions through voice.

ARCLIGHT

AI/ML APIAntigravityAssistants API+6

VoiceAI The Real-Time Voice Topic Companion

A real-time voice AI companion that lets you discuss any topic naturally, ask questions, simplify or go deeper, and challenge ideas through adaptive counter-questions, with live web search and sentiment-aware conversations.

Unpod

AIMLAI/ML APIAntigravity+15

Voni | complex workflows with a voice agent

Voni agents do more than answer questions. You can connect them to your tools, APIs, databases, and business systems. This allows an agent to read information, create records, update data, and run complex workflows.

Voni

AI/ML APIAssemblyai GuardrailsAssemblyai Guardrails API+5

Git Lens: AI-Powered Onboarding Tours

Git Lens mines your repository's history and uses AI to generate a narrated, significance-ranked onboarding tour, helping new developers understand the codebase quickly.

Wire Coffins

AI/ML APIDeepSeek V3Anthropic Claude+1

30apps loaded