The IDE Reimagined: JetBrains Codex Hackathon

We built a self-healing coding agent that searches over compact DSL implementation plans before generating code. The LLM proposes semantic reasoning branches, while a Rainbow RL controller learns which branch to select, refine, compile, backtrack from, or terminate using verifier feedback from compile and tests. This decision can be passed back to the LLM to converge to a final solution by pruning the search space. On our held-out synthetic benchmark, Rainbow with Gemma E2B (2 billion parameters) matches Codex 5.4 Low’s 80% solve rate while using roughly 140x fewer tokens and running about 4x faster. Developed and evaluated entirely on a single M3 MacBook Pro, this is an existence proof that a modular learned reasoning layer can help small local models approach frontier-agent performance at a fraction of the cost. The key idea is not to replace the LLM, but to spend expensive LLM budget only on branches that are likely to work, turning code repair from one-shot generation into a learned, verifier-guided search process.

Scopecreep turns your JetBrains IDE into an agentic hardware testbench. Describe a test in plain English; an AI agent writes Python directly into your open project, runs it against real lab instruments on your bench, and drops a timestamped results file back into the project tree. The problem. Hardware bring-up today is a context-switch nightmare. Engineers write driver code in an IDE, flip to vendor software (WaveForms, bench PSU apps) to poke the instrument by hand, copy numbers into a spreadsheet or lab notebook, then write up results somewhere else entirely. Test code drifts out of sync with the hardware it's supposedly validating. Tribal knowledge about instrument quirks — safety limits, wiring gotchas, API shapes — lives in one senior engineer's head and dies when they leave the team. Every new hire re-learns the same bench the hard way. How Scopecreep solves it. The plugin bundles a managed Python sidecar that speaks REST to actual hardware —Digilent Analog Discovery (scope, AWG, PSU, DIO) and FNIRSI DPS-150 bench supply. A chat agent, grounded in a Supabase-backed memory layer of instrument profiles, generates project-structured test code: experiments/*.py scripts that drive the hardware, results/*.md files with pass/fail verdicts and raw measurements, plus the exact terminal command to run it all. When the agent encounters an instrument it's never seen, it researches the device live, publishes a profile, and every future user across every project benefits on turn one — a shared memory flywheel instead of siloed tribal knowledge. Safety is enforced in-prompt and at the driver: the agent narrates a plan and waits for explicit user approval before energizing anything; every PSU/AWG call is wrapped in try/finally rails that disable outputs on any error path; voltage and current clamps are non-negotiable. The result: test code, instrument drivers, and the conversation that produced them all live in one version-controlled project. No tool-switching. No lost context. No DUT cooked because someone forgot to disable a rail. Built as an IntelliJ Platform plugin (Kotlin) + Python sidecar (FastAPI, pyftdi, pydwf, custom DPS-150 CDC driver) + Supabase + OpenAI function-calling agent. Ships as a single installable plugin zip.

Mesh Code: shared session state for coding agents. Install mesh-code-mcp in any IDE and any agent — Claude, Cursor, Codex — sees the same feature card, event ledger, and decisions. Close one laptop, open another: resume mid-sentence. No cold boot.

Periscope is a local-first viewer that shows you exactly what's in your coding agent's context window, turn by turn, and tells you what to do about it. What it does - Visualize the context of any agentic coding session, grouped by turn, so you can see what's actually filling the window - tool outputs, file reads, stale plans - Analyze the session to surface bloat, repetition, and rot. - Recommend the next move - compact, branch off, start fresh, rewind so you can shape context instead of just watching it grow. - It runs locally, so your session logs are protected - Lives inside JetBrains as a plugin, so you can read your context next to the code you're writing. - This could be built on ACP protocol since it works across agents - Codex, Claude Code, Copilot, Gemini, Cursor, Amp, and more - by parsing each agent's session format directly Why it matters The success of an agentic coding session is determined by three things: the model, the harness, and the context. The first two get all the attention and keeps improving. Context is the one you control, but also the one with almost no visibility today. Long sessions silently degrade: context rot sets in, the agent starts contradicting itself, tool outputs crowd out the context. However, current agentic tools give do not provide enough visibility into the context to improve it. Our personal inspiration The main inspiration to build this was our own observations on the context growing constantly, and quality degrading. We tried to solve it with the recommendations from Claude team (eg: https://x.com/trq212/status/2044548257058328723) to improve the context quality. We wanted to make it easy to use these techniques without constantly worrying about managing context, with a good balance of autonomy and control. Tech stack Local Go server + SQLite (FTS5) + embedded Svelte 5 SPA + JetBrains plugin. Open source on GitHub.

SecureLoop turns production Sentry alerts into Codex-generated, sandbox-tested, human-approved fixes inside JetBrains.

Pinpoint is a visual annotation overlay for frontend review. Not just that, it also helps pinpoint things in complex software :)

test

The debugger-aware bug-fixing agent that actually sees what broke.

# Problem Statement ## The Crisis ROS1 (Robot Operating System 1) reached end-of-life in May 2025. Yet thousands of production robotics codebases — autonomous drone flight stacks, warehouse robots, surgical systems, defense platforms — are still running on it. Security patches have stopped. Community support is gone. The clock is running. The robotics industry knows it needs to migrate. Nobody has a good way to do it. --- ## Why This Is Hard A single production MAV (Micro Aerial Vehicle) stack like KumarRobotics can have 44 packages and over 2,300 breaking API changes spanning C++, Python, CMake, and XML. The changes are not mechanical find-and-replace. They require deep understanding of two different middleware architectures: - **Node lifecycle** — ROS1 nodes are simple processes. ROS2 nodes have a managed lifecycle with explicit state transitions. - **Build system** — `catkin` is replaced by `ament_cmake` with completely different dependency and export syntax. - **Message generation** — `generate_messages()` becomes `rosidl_generate_interfaces()` with different package membership rules. - **Logging** — `ROS_INFO()` macros become `RCLCPP_INFO()` with a node logger argument. - **Parameters** — The entire parameter server API is replaced with a typed, node-local system. - **Launch files** — XML launch files are replaced with Python launch files with different syntax and semantics. - **Service calls** — Synchronous calls are replaced with asynchronous clients. - **Action servers** — The entire actionlib stack is replaced with rclcpp_action. A senior robotics engineer who knows both ROS1 and ROS2 deeply can migrate roughly one package per day. At that rate, migrating a 44-package stack takes 3 to 6 months. That is if they make no mistakes. In drone flight code, mistakes cause crashes. Existing tools — sed scripts, find-replace guides, community wikis — produce code that doesn't compile. Engineers throw it away and start over. There is no tool today that can automate this migration at scale with the accuracy required for safety-critical systems. --- ## What We Built — Problem Statement 1: Writing & Generating Code We built an AI agent that deeply understands a ROS1 codebase — its architecture, build conventions, dependency graph, and migration requirements — and generates the complete ROS2 migration at scale. **Beyond autocomplete.** The agent doesn't suggest line completions. It reads 44 packages, identifies 3,773 breaking changes across 8 semantic categories, and generates precise multi-file patches that respect the dependency ordering between packages, the naming conventions of each repo, and the build semantics of ROS2 Jazzy. **Multi-file edits from a single instruction.** A robotics engineer types one natural language instruction in the IDE — "Convert package.xml from catkin to ament_cmake, fix rosidl_generate_interfaces to use relative msg file paths" — and the agent patches CMakeLists.txt, package.xml, header files, and source files simultaneously, then runs a real colcon build to verify. **Real-world complexity.** The KumarRobotics MAV stack is not a toy codebase. It is a production autonomous flight system with SLAM, EKF state estimation, trajectory optimization, SO3 control, and a full state machine. Our agent migrated all 44 packages across all 4 repositories. 28 packages building clean, 100% success rate, verified by colcon build in a ROS2 Jazzy Docker container. **Code that won't be thrown away.** Every AI-generated patch is validated by a real compiler. If the build fails, the agent reads the error, calls o4-mini again with the error context, and iterates up to 3 times. The output is not a diff for a human to clean up — it is working, compilable ROS2 code. --- ## What We Built — Problem Statement 3: Reviewing & Deploying Code Migration at this scale cannot be fully autonomous. Drone flight code is safety-critical. An AI that migrates the wrong actionlib server could cause a mission failure. Human judgment must stay in the loop — but in a way that doesn't recreate the 3-6 month manual process. **AI-powered code review at scale.** Our Web UI presents every finding to the engineer — not as raw diffs, but as structured, categorized, context-rich review items. The engineer approves or rejects each one, adds domain-specific instructions, and the agent executes only the approved changes. 1,595 findings reviewed and approved in a single session. **IDE-native deployment validation.** Our JetBrains plugin brings the entire pipeline into the IDE the engineer already uses. Every package shows its migration status. Every AI-generated change is visible as a side-by-side diff — ROS1 on the right, ROS2 on the left, every line highlighted. The engineer can trigger a re-run on any package, type a new instruction, and watch the agent iterate in real time in the agent log panel. **Shortened feedback loops.** The cycle from "this package has an error" to "this package is clean" is under 2 minutes. The engineer types an instruction, clicks Save & Re-run, and watches the agent patch the files, rebuild the package, and update the status from `[ERRORS: 1]` to `[✅ CLEAN]`. That feedback loop used to take days. **Full auditability.** Every change is recorded — which files were patched, how many lines changed, how many iterations the agent needed, what errors remained. The migration report gives the team a complete audit trail from ROS1 to ROS2, package by package. --- ## The Result | Metric | Value | |--------|-------| | Repositories | 4 KumarRobotics MAV repos | | Packages | 44 | | Findings generated | 3,773 | | Findings reviewed | 1,595 approved | | Packages building clean | 28/28 — 100% | | Human time saved | 3-6 months → hours | | Validation method | Real colcon build, ROS2 Jazzy, Docker | --- ## Why It Matters Every drone company, defense contractor, warehouse robotics team, and research lab with a ROS1 codebase faces this exact problem right now. The migration crisis is not hypothetical — it is happening today, and the tools to solve it do not exist. The remaining work is in the .msg field naming conventions — ROS2 requires snake_case, but renaming clsID to cls_id breaks all downstream code that references it. That's an architectural decision that requires human judgment. Our platform flags it, defers it, and keeps the human in control. That's exactly what human-in-the-loop means."

New developers opening a React repo often cannot quickly see how components nest and which file owns what. Reading files one by one or searching imports takes time and does not give a clear mental map of hierarchy, so onboarding and debugging feel slow and confusing. React Flow Visualizer is an IntelliJ plugin that scans the project and draws an interactive component graph in a side panel. Beginners can see parent–child structure at a glance and jump to source from nodes, so they can understand code layers faster.

Goldfish is an advanced, evolving AI agent designed to learn from every interaction. Unlike traditional static agents, it builds a persistent understanding of your preferences, picks up new skills on the fly, and expands its capabilities through a modular ecosystem of tools and skills. Goldfish makes coding task handy, debugging easy, reviewing large codebase like eating a small piece of pizza. Also, a plugin for JetBrains IDE was made for better user experience (see below) https://plugins.jetbrains.com/vendor/gguf https://plugins.jetbrains.com/plugin/31359-wrap

Disclaimer: due to unforeseen circumstances we have to leave before noon, so we cannot be there for the demos and pitches. That said, we had a lot of fun building it. Lintropy is a Rust-based linter and LSP server that lets you define repo-specific rules in YAML. It uses tree-sitter queries for structural matching and regex for text matching, so you can enforce conventions that generic linters like ESLint or Clippy can't, such as "API handlers must live under src/api/" or ".unwrap() is banned outside tests". Rules are enforced everywhere: CLI, CI, editors (VS Code, Cursor, JetBrains), and coding agents ( Codex, Claude Code), which matters as agents generate more code and convention drift outpaces review bandwidth. A bundled SKILL.md teaches agents the rule schema, so they can both author new rules from plain-English descriptions and fix their own violations in a write → lint → fix loop via the LSP.

Speedrunner is an AI-assisted, human-governed incident response system that cuts P1 outage response and resolution times in half by eliminating triage slop, accelerating root cause analysis, and enforcing safe, auditable remediation workflows. =========================== Speedrunner: Reducing Triage Slop in High-Severity Outages Problem In modern engineering and security operations, one of the biggest risks is not just bad code — it is bad machine-generated judgment. A growing failure mode has emerged where AI-generated outputs — whether code, alert classifications, investigation summaries, or remediation recommendations — appear polished and credible, but lack the depth, context, and accuracy required for high-stakes decisions. This creates triage slop: AI suggests plausible but incomplete root causes Operators accept outputs they cannot fully validate Small changes are pushed into complex systems without adequate review Incidents widen because the response process is fast, but not trustworthy In an e-commerce environment, this is especially dangerous. Scenario A bottleneck in checkout throughput causes a production outage. Impact Severe business impact Widespread loss of site functionality Customers cannot complete checkout Immediate revenue loss High executive visibility P1 / critical incident conditions Traditional P1 Targets Response time: 15 minutes to 1 hour Resolution time: 4 to 8 hours These targets are often missed because teams lose time in: identifying the blast radius comparing codebase versions reviewing logs and deployment history determining whether the issue is infra, app, config, or release related producing and validating a safe patch coordinating approvals and deployment The Goal: Reduce Triage Slop Speedrunner is designed to reduce the time wasted on low-confidence AI output and replace it with a structured, auditable, human-supervised incident acceleration workflow. Target Outcomes with Speedrunner Response time: reduced from 15–60 min to 7–30 min Resolution time: reduced from 4–8 hours to 2–4 hours 50% improvement in incident response speed Higher confidence in remediation Lower risk of unsafe AI-generated fixes reaching production How Speedrunner Works Speedrunner accelerates P1 outage resolution through a preplanned incident workflow with controlled automation and mandatory human validation. 1. Preplan Before incidents occur, Speedrunner defines: critical service dependencies system ownership known failure patterns rollback paths test harnesses approval chains production deployment guardrails This eliminates delay during live incidents. 2. Activate Codebase Version Compare When an outage begins, Speedrunner automatically: compares current production code against the last known good version identifies recent commits, config changes, feature flag updates, and dependency shifts highlights suspicious diffs tied to checkout, payments, session handling, inventory, or APIs This narrows the likely fault domain within minutes. 3. Activate Code Optimization / Root Cause Agents Specialized agents examine: performance regressions throughput bottlenecks thread saturation DB lock/contention issues queue buildup API latency spikes cache failures resource exhaustion logic changes that could block checkout completion Important: these agents do not act autonomously in production. They generate hypotheses, ranked by confidence and evidence. 4. Review Log Files Speedrunner pulls and correlates: application logs infrastructure logs load balancer and CDN logs DB slow query logs queue/stream health tracing and telemetry data error rate spikes transaction abandonment patterns This prevents responders from relying on a generic AI summary detached from actual system behavior. 5. Review Release Records / Deployment History Speedrunner checks: what changed who changed it when it was deployed whether it coincides with the outage window whether similar changes have caused failures before It also inspects: canary results failed deploy signals rollback history feature flags config drift This creates an evidence-backed release timeline. 6. Create Patch Once a likely root cause is identified, Speedrunner can generate a patch proposal. Possible actions include: rollback recommendation config hotfix query optimization concurrency limit adjustment circuit breaker tuning feature flag disablement temporary checkout degradation mode / workaround full code patch The key difference is that the patch is generated alongside: reason for recommendation impacted components expected tradeoffs rollback instructions test plan 7. Test Patch: Unit / QA / Stage No direct “AI-to-prod” flow. All fixes move through fast validation: unit tests targeted regression tests synthetic checkout testing throughput validation QA smoke test staging verification against outage symptoms If necessary, Speedrunner prioritizes service restoration over perfection, allowing a workaround first and a complete fix second. 8. Human-in-the-Loop Sign-Off Every production remediation requires: 2-person approval one technical owner one operational or incident authority This is the core control that reduces triage slop. The AI can accelerate: analysis diffing summarization patch drafting test generation But it cannot unilaterally decide. 9. Deploy to Production Once approved, the fix is deployed with controlled release safeguards: canary rollout staged traffic ramp rollback automation post-deploy telemetry checks checkout success rate validation business KPI monitoring If customer checkout is restored, the incident is stabilized even if deeper cleanup continues afterward. Why This Works Traditional Failure Mode In many organizations, AI reduces the cost of producing output, but not the cost of validating it. That creates: fast but shallow triage overconfident summaries unsafe remediation false root-cause certainty delayed recovery when the “AI answer” is wrong Speedrunner’s Model Speedrunner treats AI as a compression layer for evidence gathering, not a replacement for operational judgment. It speeds up: signal collection timeline building change correlation patch drafting test preparation While preserving: human review approval controls production safety auditability Core Design Principles 1. Evidence Over Fluency AI outputs must cite: logs traces commits release events metrics failed transactions If a recommendation cannot be tied to evidence, it is not action-ready. 2. Narrow Blast Radius All remediation is designed to: isolate failure domains prefer rollback or feature disablement first avoid broad changes during incident pressure 3. Human Accountability No production action without named reviewers. 4. Fast Safe Workarounds The objective is not always “perfect fix first.” The objective is: restore checkout stop revenue loss stabilize the environment then complete permanent remediation 5. Auditable Incident Chain Every recommendation and action is logged: what was suggested what evidence supported it who approved it what was deployed what outcome followed Example P1 Outage Flow Minute 0–5 Incident triggered Checkout error rate spikes Throughput drops Revenue impact flagged Speedrunner opens incident context Minute 5–10 Compares current prod version to last known good Correlates logs, traces, release history Detects recent checkout service change and DB latency increase Minute 10–20 Generates ranked root-cause hypotheses Suggests either rollback or config patch Produces synthetic test plan Minute 20–35 Team validates in QA/staging Two-person signoff completed Canary release starts Minute 35–60 Checkout recovery confirmed Revenue flow restored Incident downgraded from active outage to monitored recovery This is how response compresses from 15–60 minutes into 7–30 minutes, and resolution compresses from 4–8 hours into 2–4 hours. Business Value Immediate Benefits Faster incident response Faster service restoration Less revenue loss per outage More consistent P1 handling Better operator confidence Risk Reduction Prevents “vibe coding” in incident response Stops low-confidence AI recommendations from reaching prod unchecked Reduces blast radius from rushed fixes Improves change governance under pressure Operational Benefits Standardizes outage triage Preserves institutional knowledge Shortens onboarding time for responders Creates reusable incident playbooks

PR Autopilot: The AI Architect for Modern Dev Teams Tagline "Stop reviewing nits. Start shipping architecture." The Vision PR Autopilot is a next-generation AI code review suite designed to eliminate the #1 bottleneck in the software development lifecycle: the manual code review. While traditional linters focus on syntax and style, PR Autopilot functions as a virtual Senior Architect, analyzing every pull request for architectural integrity, deployment risk, and technical debt. The Problem Development teams are drowning in PRs. Senior engineers spend up to 40% of their time reviewing boilerplate changes, leading to "review fatigue" where critical architectural flaws and security vulnerabilities slip through the cracks. Simultaneously, writing high-quality PR descriptions is a chore that developers often ignore, leading to poor historical documentation. The Solution PR Autopilot leverages Codex Turbo (our custom-tuned AI engine) to provide a dual-layered defense for your codebase: The Web Dashboard: A stunning, glassmorphism-inspired interface for interactive architectural analysis. The CI/CD CLI: A seamless GitHub Action that provides automated line-level feedback directly on the diff. Key Features 🔴 Architectural Risk Scoring: Instantly calculates the "Blast Radius" of a change, labeling PRs as High, Medium, or Low risk before a human even opens them. 🏢 Senior-Level Insights: Goes beyond "nitpicking" to identify design pattern violations, modularity issues, and potential performance regressions. 🧪 Test Gap Analysis: Automatically identifies specific missing unit tests or edge cases based on the modified logic. ✍️ The "Ghost Writer": Generates professionally formatted GitHub PR descriptions in seconds, including technical decision summaries and impact analysis.

Guardia is a deployment risk copilot integrated within JetBrains IDE that can proactively alert developers about risks in their code before deployment. Grounded in DataDog data and prior incident history, it can point to the exact line of code that would break the existing codebase before a PR is pushed. Guardia also has auto healing capabilities and can automatically fix the code, explain why it is a deployment risk, and tie it to the exact incident number that was caused by similar code, e.g. a null pointer exception error in the same service. The key differentiator of Guardia is it is written for developers working in enterprise environments: it bundles all the context from incident data, with Codex as the reasoning layer to allow developers to push code more effectively. Developers can feel assured shipping features quickly knowing they have a safeguard that can proactively detect incidents before they happen.

Context-aware adversarial testing for Machine Learning and Ranking pipelines, built directly into the JetBrains IDE.

Category : Testing & Debugging Code Training LLMs is expensive. Burning hours on an H100 only to discover your model was memory-bound the entire time is an expensive mistake and it happens constantly. Live Roofline Analyzer fixes that. It's a VS Code extension that shows you exactly what's bottlenecking your transformer — compute or memory — in real time, right inside your editor. Open any Python training file, and it auto-detects your model architecture, plots every transformer operation on a live roofline chart, and tells you precisely which ops are wasting your GPU. Drop one Python file next to your training script and the panel updates live as training runs, showing step count, tokens per second, and a continuously updated roofline. No more guessing. No more profiling after the fact. No more wasted compute. Supports TPU v4/v5e/v5p, A100, H100, and H200 out of the box, with one-click presets for LLaMA 3 8B/70B/405B, Mistral, Gemma, and GPT-2. Hit one button and GPT-4o streams back concrete optimization suggestions — batch size, precision, parallelism strategy — based on your actual numbers.

Hindsight is a local-first memory layer for AI coding. It tracks coding attempts inside JetBrains, including edits, test runs, failures, and reverts, then turns them into a structured attempt history. Through our MCP integration, agents can also query prior attempts before trying a new fix, helping them avoid repeating the same dead ends. We sync attempts to Supabase and surface them in a dashboard so teams can inspect failures, recoveries, and task history across projects. This directly tackles Problem Statement Two, "Testing & Debugging Code", by shrinking the gap between 'something failed' and 'here’s what was already tried.' It also supports Problem Statement One, "Writing & Generating Code", by giving coding agents memory of prior failed and successful approaches so their generated changes are more context-aware and less disposable. Long term, we think this can become a core layer for AI-assisted software development: a shared memory system for individuals and teams that makes agents more reliable, reduces duplicated debugging effort, and preserves high-value engineering knowledge that would otherwise be lost.

RedGreen is a JetBrains plugin that turns the IDE into a self-healing runtime. When the PyCharm debugger trips a runtime exception, RedGreen races four models in parallel — each steered by a different "hypothesis lens" (null bug? wrong input shape? race condition? config drift?) — to produce a failing test, a patch, and a rationale. Every candidate has to survive four automated gates before it can reach the developer: Runner (pytest in a Docker sandbox — does the test reproduce the bug and the patch flip it?), Peers (the patch is re-run against every other agent's test — hacks that only pass their own test are filtered out), Regression (the patch runs against the repo's existing test suite — if it fixes the target bug but breaks an unrelated feature, it's disqualified), and Review (a small LLM picks the most idiomatic survivor based on code-review principles). The winning patch surfaces as a gutter inlay — one click to apply. Every episode writes to a per-codebase leaderboard. Later episodes read history and bias (hypothesis, model) assignments toward known winners — so the tool gets faster and more accurate the more you use it on the same project. The problem: every developer loses hours to the inner debug loop. RedGreen compresses that loop to 30 seconds, with three independent layers proving the fix is real before a human has to look at it.

VoiceCodex is a JetBrains plugin running inside WebStorm that turns the IDE into a hands-free conversational coding partner. You just talk naturally, keep your hands off the keyboard, and watch Codex do the work inside your IDE

Plannotator Live (built from scratch at the hackathon) is a collaborative planning review surface for agentic engineering; built for the world where coding agents are fast but planning and review have become the new bottlenecks. It reframes "PRs" as Plan Reviews: a multi-player workspace where humans and their agents align on the plan upfront, with end-to-end zero-knowledge encryption so plans stay private. The goal is better generated outcomes through better collaboration before code is ever written.

ChainMail Council AI writes code faster than humans can review it. There's no governance layer — no accountability, no audit trail, no way to know what changed, why, or who approved it. Council is that layer. Before any AI-generated change touches your codebase, a council of specialized models deliberates and votes. Codex — running inside JetBrains — reads the task, selects the right agents, and fires them in parallel against Nebius Token Factory: Qwen3 235B, Nemotron Ultra 253B, Nemotron 120B. Three independent MoE models. Three votes. A human verifies with a FIDO2 hardware key. Gemma on a sovereign VM synthesizes the consensus. Every deliberation writes to MMCP Bubble Memory — a pgvector store on our H100, semantically searchable, permanently retrievable. Every audit entry is SHA-256 hash-chained to the one before it. You can't delete a decision without breaking the chain. Eight pillars: shared context · sovereign memory · BYOK · identity · accountability · retrievability · reversibility · ledgerbility Stack: Nebius H100 VM · Nebius Token Factory (MoE) · NousResearch Hermes Agent · MMCP Bubble Memory · Supabase Edge Functions · OpenAI Codex (JetBrains) · FIDO2 Bkey · Snap Spectacles AR This is the infrastructure layer that enterprise AI has been missing. Not a chatbot. Not a copilot. Governance. missing the CMO = Gemma 4 + Apify + Mind AI + Vis-AI-Vis for customer discovery interviews. because knowing what and why is equally as important as knowing when and how. and IDEALLY for WHO!!!! apify pulls all social, mindsAI builds ICP, vis-ai-vis conducts the face to face with ai in the middle interviews. equals a governed result with the council. and creates the GTM! Apify → pulls social signals (Reddit, X, LinkedIn, reviews) Mind AI → builds ICP from those signals Vis-AI-Vis → conducts AI-mediated face-to-face customer interviews Gemma 4 → synthesizes into CMO brief (WHO + WHAT + WHY) ↓ CMO council vote — evidence-backed, not inferred ↓ Council consensus → governed GTM

TRUE (https://supabase-true.vercel.app/): No review bottlenecks. No merge conflicts. No broken tests. No wasted hours debugging AI-generated code. Every change is verified before it lands, so only proven code gets through.

A plugin that adds a Spatial pane to the IDE and MCP commands to allow an agent to render anything in 3D spatial visualizations for the user. This can range from project information to explainers about how the project algorithms work. The agent can use camera movement and speech to create a narrative, and the spatial visualization can be interactive. Note it works with Immersive WebXR too: https://youtu.be/JSIVpX6DGY0

ShipSec Local is a local-first security review plugin and workflow for Codex. It builds a repo-wide security model, saves a trusted baseline, and then compares the current working state against that baseline to surface newly introduced attack vectors, widened trust boundaries, and important existing risks. It also supports clean-room verification in Docker so teams can run the same review flow in an isolated Codex environment.

We are creating an AI Forward Deployed Engineer that helps organizations work together and onboard unknown systems and work with multiple systems. For now we are working with ERP systems to data ingestion, to onboard various and unknown system automatically using multiple agents which research and improve iteratively and then deploy the pipeline automatically.

Rodex IDE - A Cursor-style IDE that uses 4 AI agents (powered by Nebuis Coding Model + Blaxel sandboxes) to perform real-time security analysis, bug detection, and autonomous fix application on Python codebases.

AI coding agents like Codex can feel like a black box to non-technical users. Most people don’t think to ask for a plan first, which makes it hard to understand what the agent is doing, what it intends to build, and how the work is unfolding. VisualCode turns a simple user request into a structured plan and visualizes that plan as a growing tree graph. By breaking the work into clear branches, it gives users an intuitive view of what the AI agent is building, how it is thinking about the task, and how the project is being organized from idea to implementation.

My solution is designed to simplify the lives of both technical and non-technical users by bridging the gap between business workflows and software development. For non-technical users such as marketing and sales teams, the platform enables the creation of high-quality, executive-ready presentations with minimal effort. By simply uploading an Excel file and a reference PowerPoint template, users can automatically generate structured, insight-driven slide decks. This eliminates the time-consuming process of manual analysis and slide design, allowing teams to focus on decision-making rather than formatting. On the technical side, the solution introduces an intelligent development workflow powered by an AI agent. Users can submit feature requests or bug reports directly through the application, which are automatically converted into actionable tickets. The system then analyzes the codebase, generates proposed changes, and presents them as structured diffs. Developers remain in control by reviewing and approving these changes, after which the system automatically applies the updates and deploys them. By integrating content generation with an autonomous yet human-in-the-loop development pipeline, this solution significantly reduces turnaround time from idea to execution. It creates a unified experience where business users can request changes and developers can implement them with minimal friction, ultimately accelerating both productivity and innovation.

OmniDev is a background coding agent you can hear, talk to, and carry with you. Start a job on a real GitHub repo and a durable workflow spins up a Vercel Sandbox, clones the branch, plans, edits, and opens a pull request — while narrating its reasoning out loud through Gemini Live. Redirect it mid-flight by speaking into your mic. When the agent hits a blocker it can't decide alone, it calls your phone over Twilio: an AI persona explains the problem in one sentence, you answer, and the job resumes. A native macOS menu-bar overlay lets you cmd-tab between parallel agents from the notch, and a Tauri shell extends the same product onto the desktop. Built on Vercel Sandboxes for isolated execution, Supabase Postgres for durable job state, a GitHub App for repo access and PRs, and Nebius-hosted OSS models for agent reasoning.

MemoryLint is the IDE-native trust and governance layer for AI-written code inside JetBrains. AI coding agents don't govern themselves. They can remember deleted code, violate architecture rules, leak context across projects, and produce changes that are hard to audit. MemoryLint sits between the agent and the keystroke: it decides what agents are allowed to remember, recall, and act on — and proves every decision with a signed audit trail. In the demo, MemoryLint shows up as a real JetBrains plugin: a live red squiggly appears on an unsafe System.getenv(...) call, Alt+Enter triggers a governed auto-fix via OpenAI Codex, the line is rewritten to ConfigService.get(...), the missing abstraction is scaffolded automatically, and the decision is logged to audit with a deep link into the dashboard. Underneath that IDE experience, MemoryLint uses: AuthZed / SpiceDB for Zanzibar-style authorization on governed recall Nebius Token Factory for multi-model consensus on high-severity decisions Supabase Storage for signed compliance evidence packs Neo4j for provenance and blast-radius traversal FastAPI + Next.js + JetBrains plugin as the product surface This project maps cleanly to all three hackathon tracks: Writing & Generating Code — governed code rewrites inside JetBrains Testing & Debugging Code — ShadowQA mutation testing and TraceOS incident analysis Reviewing & Deploying Code — Ship Gate, evidence packs, and audit-backed governance Assistants generate. MemoryLint governs. Built solo in 48 hours. 1,900+ tests, 65 dashboard pages, 42 backend services, 22 Kotlin files across 8 IntelliJ SDK surfaces.

Blueprint is a PyCharm plugin that helps developers plan their codebase before implementing it, making AI-assisted coding more structured, predictable, and easy to reason about. It gives developers a clear architectural overview by analyzing an existing Python project and turning it into editable Mermaid UML, or by letting them sketch a design first and refine it through an AI-assisted side chat. Once the architecture is ready, Blueprint converts the design into scoped, dependency-aware implementation nodes, then guides each change through planning, code generation, review, diff preview, validation, and apply. This creates a safer loop from architecture to code, helping developers use AI with more control, better context, and fewer unreviewed changes.

Adaptive Change Harness is a self-evolving verification and repair system for real codebases. Its core value is not just that it can call a model to suggest a patch, but that it wraps models inside a reproducible evidence loop: ingest a repo, discover a real latent failure, save the exact repro, repair it with grounded context, rerun deterministic validation, and then convert validated fixes into reusable repair skills. The product gets stronger over time because each successful repair becomes structured runtime knowledge that can be matched, reused, and improved on future failures. The most eye-catching part is that it turns model output into hard operational proof. Instead of stopping at “the AI thinks this bug is fixed,” it shows failure before repair, no failure after repair, and passing baseline tests, all inside an operator-facing run console. It can capture latent bugs that baseline tests missed, replay them deterministically, generate and apply a patch, and end with a safe or unsafe verdict backed by evidence. On top of that, it automatically creates or updates a skill library from validated repairs, making the system visibly self-evolving rather than a one-off patch generator. Standout features: • Real repo intake and profiling from uploaded zip files • Latent failure discovery with saved reproducible failure cases • Deterministic replay-based repair validation • OpenAI-powered grounded diagnosis and patch generation • Evidence-first verdicts instead of confidence-only outputs • Automatic creation, reuse, and revision of repair skills in skill_assets/ • A run console that makes the full discover -> repair -> validate -> learn loop visible end to end

Is a reimagined IDE for computational biology that treats biological correctness as a first-class debugging target. Utilizes ConTree's pipeline branching, it replaces the broken silence of bioinformatics failures — where pipelines complete successfully but produce wrong science — with three AI agents: BioTrace (traces a bad result back to its root cause), BioFuzz (stress-tests pipelines with synthetic biological edge cases before they run), and BioReview (reviews analysis code the way a peer reviewer would). The IDE surface shows a live pipeline branch tree, a streaming debug console, and an auto-generated methods section — all in one canvas.

Code with voice(and not in english). We developed a customized model to code in Indic languages (Tamil, Hindi and Bengali). The pipeline starts from IntelliJ plugin Recording flow: Alt+Shift+R starts recording Alt+Shift+S stops recording and auto-submits the WAV file the backend generates a prompt and runs codex exec against the project root

Bug Bounty is a super heavy cutting edge research project on how dangerous ai agents can be to the world of software what we can do to mitigate it? these ai agents are impossible to defend from , the solutions is describing the danger level learning from it and creating mitigation pattern as it happens . Creates Honey pots and miotigation systems for the aio agents and also attacks or hacks them ethically.

Review vibe-coded repository output for security, design quality, explainability, and engineering metrics.

Skills for coding agents to run code systimatically

The coding agent to solve all problems, it has as many tools as you need, with a ui handcrafted with taste Your next move, on cue.