🤝 Top Collaborators
.png&w=640&q=75)
.png&w=640&q=75)
🤓 Latest Submissions
Repoflare
RepoFlare: Eliminating Code Change Blind Spots via Deterministic Graph Intelligence 1. The Problem: High Friction in Code Review and Maintenance When developers modify code during maintenance, feature additions, or onboarding to a new project, understanding downstream impact across files, functions, and tests is high-friction and error-prone. Engineers either grep manually, guess, or rely on slow CI test runs to catch regressions. Conventional AI coding assistants suffer from a critical blind spot: they treat code repositories as unstructured text, re-reading or re-embedding entire codebases on every prompt. This approach is slow, costly, and produces unverifiable assertions without structural proof, leading to review fatigue, rework, and silent production defects. 2. The Solution: RepoFlare Knowledge Graph Engine RepoFlare transforms repository maintenance and code review by decoupling structural impact traversal from semantic reasoning. It builds and incrementally maintains a lightweight, local knowledge graph stored in DuckDB, parsing ASTs via Tree-Sitter to map files, functions, classes, imports, and tests as explicit nodes and edges. When evaluating a change (`git diff`), RepoFlare operates in two distinct phases: 1. Deterministic Impact Traversal (Zero AI Overhead): RepoFlare traverses the graph backwards in milliseconds to identify affected downstream symbols and unit tests. Operating 100% deterministically and offline, it categorizes impact into `DIRECT`, `INDIRECT`, `RELATED`, and `POSSIBLE` dependencies with zero API cost. 2. Grounded AI Explanation: For semantic reasoning, RepoFlare submits only a bounded, graph-selected context package to the LLM. Every claim in the response mandates explicit, line-level citations (e.g., `[utils.py#L1-L3]`), enabling reviewers to verify reasoning immediately rather than blindly trusting LLM output. 3. Prototype Built with IBM Bob 2.0 We leveraged IBM Bob 2.0 in Agent Mode to engineer two production-grade subsystems of our working prototype from architectural specifications: VS Code Extension Shell: Bob autonomously built the entire TypeScript extension layer (`rpc.ts`, `extension.ts`, `panel.ts`, `webview.ts`), implementing a JSON-RPC 2.0 stdio client that communicates seamlessly with our shared Python core, complete with an interactive SVG dependency graph renderer. DuckDB Response Caching Module: Bob engineered `cache/provider.py`, implementing content-hash-keyed result caching in DuckDB. Repeated queries on unchanged code hit the local cache instantly, eliminating redundant network calls and reducing LLM latency to zero. 4. Measurable Impact on Developer Workflows RepoFlare streamlines developer workflows across code review, onboarding, and application maintenance: Reduces Manual Effort & Rework: Converts multi-hour manual dependency tracing into a <10ms deterministic graph lookup, eliminating pre-merge blind spots. Dramatically Cuts API Cost & Latency: Bounded context packages and Bob’s caching module reduce LLM token consumption by over 80% compared to full-repo re-indexing. Zero-Trust Verification: Line-level citations remove ambiguity during code reviews, allowing developers to audit AI explanation claims in seconds. RepoFlare proves that pairing deterministic graph traversal with targeted AI reasoning creates a faster, cheaper, and fully verifiable workflow for modern software development
27 Sep 2026
HedgeMePlease
HedgeMePlease is a trading agent that ran a $100,000 Alpaca paper account on its own for the four contest days. No human placed or approved a single trade. It finished at $100,200.69, and the way it got there matters more than the number: the most capital it ever had at risk at one time was $1,916, under 2% of the account. On that deployed capital the return was 10.6% in four days. The worst the account ever dipped inside a day was 0.19%, against a 5% team limit. Seven trades, six winners, and the one loser was insurance we bought on purpose. It made money three ways. Strategy A sold iron condors on ETFs like SPY, but only when four separate checks confirmed options were overpriced versus our own volatility forecast (all 4 trades won, +$174). Strategy B sold the earnings volatility crush on DELL and AVGO in the final minutes before each report (+$118, both won; DELL moved its full expected range overnight and the trade still profited). Strategy C bought a cheap SPY put as crash protection so the other two could stay invested through a tense news week (-$88, the cost of the insurance). Under the hood, a LangGraph state machine wakes every five minutes and pulls live data through Alpaca's official MCP server, the only path to the broker in the codebase. Six DeepSeek agents read the market regime, pick trades, veto on news, time the hedge, and write a diary of every cycle. They can only reduce risk, never increase it: every limit is hard-coded, ending in a kill switch at -3.5% that never came close to firing. Every decision, including refused trades, is logged with the agent's reasoning next to the resulting P&L. Five real bugs were found and fixed live mid-contest without missing a single planned trade, the books are reconciled against the broker every five minutes, and 102 offline tests cover the whole pipeline. http://13.90.28.24:8080/?k=hedgeme26
4 Sep 2026
smart token efficient agent
Our submission for the AMD Developer Hackathon is a highly optimized, hybrid AI agent designed to maximize token efficiency while maintaining rigorous accuracy standards across complex evaluation tasks. To achieve this, we engineered a local-first cascade system. The agent runs entirely within the strict grading constraints (CPU-only, 4GB RAM) by bundling a highly quantized `gemma:2b` model running locally via an embedded Ollama server. This local instance acts as our zero-cost primary solver, immediately handling simpler queries in categories like factual Q&A and sentiment analysis without consuming any external API tokens. When the local model detects low confidence or encounters complex reasoning, math, or coding tasks, the agent dynamically escalates the prompt to the cloud-based Fireworks AI API. We strictly constrain this fallback tier to utilize only the allowed Gemma 4 models (such as `gemma-4-31b-it`). By intelligently routing queries—using local compute for the easy tasks and reserving the cloud API solely for the difficult ones—our agent achieves an exceptional balance of high accuracy (easily passing the 84.2% gate) and minimal token expenditure. The entire system is packaged in a lean, self-contained Docker image well under the 10GB limit.
13 Jul 2026
