DEV Community: Eugine Noel

Inside J3D Eye: Building a Real-Time Global Camera Intelligence & OSINT Dashboard

Eugine Noel — Fri, 02 Oct 2026 09:02:29 +0000

Hey everyone! 👋

When expanding JED AI (https://jedcorp.ink) beyond automated vulnerability scans and terminal orchestration, we wanted to tackle a different kind of challenge: real-time global telemetry and visual intelligence.

Enter J3D Eye: our global camera intelligence and OSINT dashboard designed to aggregate live multi-source video feeds, satellite overlays, and perimeter feeds into a unified command center.

Here is a breakdown of how we built it and why real-time geospatial intelligence visualization matters for modern security operations.

👁️ What is J3D Eye?

J3D Eye acts as an immersive surveillance and OSINT workspace within JED AI. Instead of switching between isolated monitoring utilities, analysts can use the dashboard to:

Interactive Geospatial Mapping: Navigate satellite overlays and map markers to pinpoint active regional feeds in real time.
Multi-Cam Grid & Camera Wall: Toggle seamlessly between list views and multi-feed camera walls to monitor multiple global traffic and infrastructure streams simultaneously.
Live Stream Telemetry & Probes: Run live probe passes, monitor feed health statuses (online/offline indicators), and inspect feed metadata directly from the console overlay.

⚙️ Architecture & Engineering Highlights

Building a smooth multi-stream video dashboard required solving several interface and performance bottlenecks:

Dynamic Grid Layouts: Built with responsive CSS/JS grid structures that let operators instantly scale, pop out, or manage multiple simultaneous live video streams without lagging the browser.
State & Feed Monitoring: The probe console continuously pings and tracks feed states, dynamically updating status lights and handling offline feed fallbacks gracefully.
Immersive Dark-Mode Tactical UI: Designed with high-contrast tactical overlays, custom map legends, and workspace tab switching (allowing operators to jump instantly between J3D Eye, Globe Live, AI Chat, and the Kali Armory).

🚀 Try It Out

J3D Eye is part of the live JED AI ecosystem, which currently supports 12k registered users, over 10k executed scans, and 15k+ security findings.

You can explore the platform and test out the live dashboards here:

Live Platform: https://jedcorp.ink
GitHub Repository: https://github.com/jed254silk

How do you approach real-time data streaming or multi-source feed aggregation in your web apps? Let's discuss in the comments below! 👇

Inside the Kali Armory: How JED AI Integrates 33+ Security Tools Into a Web-Based Agent

Eugine Noel — Fri, 02 Oct 2026 08:53:25 +0000

Hey everyone! 👋

When building JED AI (our cloud-native autonomous security platform at https://jedcorp.ink), one of the biggest engineering hurdles wasn't just getting an LLM to chat about security—it was building a reliable backend bridge to actual command-line utilities.

Standard security workflows require jumping between terminals, managing local dependencies, and manually chaining tools like Nmap, Amass, and SQLMap. To fix this, we built The Kali Armory: a unified, cloud-hosted execution environment integrated directly into our ReAct agent pipeline.

Here is a quick look at how we architected it and why moving terminal tools into a browser-based agent changes the game.

🛡️ What is the Kali Armory?

Instead of forcing developers and security researchers to juggle local Kali Linux environments or container setups for every scan, the Kali Armory integrates 33+ core security tools directly into JED AI's backend architecture.

When a user issues a natural language or voice directive (e.g., "Perform a stealth port scan and check headers"), the autonomous agent:

Parses Intent: Decides which tools are required for the task.
Chains Execution: Sequentially runs utilities (such as Amass for subdomain enumeration followed by Nmap for port mapping).
Streams Telemetry Live: Captures raw stdout and stderr streams, piping them directly to the frontend via Server-Sent Events (SSE).

⚙️ The Technical Challenge: Safety & Process Isolation

Running arbitrary or powerful CLI security tools via an automated backend agent introduces massive risks, particularly command injection and resource starvation.

To keep the system secure and stable, we implemented:

Strict Parameter Sanitization: User inputs and agent-generated arguments are heavily validated before being passed to subprocess wrappers.
Isolated Execution Wrappers: Every tool invocation runs within controlled Python subprocess boundaries, capturing outputs safely without exposing the host server.
Lightweight Telemetry Loop: Long-running scans don't block the web server. Gunicorn manages concurrent worker threads while state is tracked efficiently via SQLite.

🚀 Try It Out

The Kali Armory is fully integrated into the live JED AI platform, which currently supports 1.2k registered users, over 10k executed scans, and 15k+ identified findings.

You can check out the live sandbox and platform here:

Live Platform: https://jedcorp.ink
GitHub Repository: https://github.com/jed254silk

How do you handle tool orchestration or process isolation in your own security automation scripts? Let's discuss in the comments below! 👇

Building JED AI: An Autonomous Security Agent Executing 45+ Tools via Real-Time SSE

Eugine Noel — Fri, 02 Oct 2026 08:45:09 +0000

Hey everyone! 👋

As developers, we’ve all been there: you want to run a quick security audit or reconnaissance sweep, but you end up bogged down juggling local terminal CLI tools (Nmap, Amass, SQLMap, etc.), managing dependencies, and parsing massive blocks of raw text.

Even worse, standard AI "chat wrappers" just give you text advice on how to run commands—leaving you to do all the heavy lifting manually.

I wanted to bridge the gap between AI reasoning and real system execution. So, I built JED AI (https://jedcorp.ink) — a cloud-native, web-based autonomous security agent that lets users run multi-tool audits, OSINT reconnaissance, and vulnerability scans entirely in the browser using natural language or voice prompts.

⚙️ How It Works (The Architecture)

ReAct Agent Loop: Built with a custom reasoning and acting loop in Python (running on Gunicorn) that breaks high-level user directives down into discrete tasks (e.g., resolving subdomains via Amass, mapping ports via Nmap).
Process Isolation & The Kali Armory: It securely orchestrates 33+ integrated Kali tools on the backend, capturing raw stdout/stderr streams without exposing the host server to unsafe command injection.
Real-Time SSE (Server-Sent Events): Instead of waiting blindly for a long-running security scan to finish, the frontend receives live telemetry chunks via Server-Sent Events, updating the mission planner UI in real time.
Tech Stack & State: Powered by a Python backend, SQLite storage, JWT auth, Cloudflare Tunnel compatibility for secure remote access, and integrated Paystack infrastructure for billing/subscriptions.

🚀 Traction & What's Next

JED AI is live, monetized, and actively growing! It currently serves 1.2k registered users, with over 10k executed scans and 15k+ security findings logged.

If you're interested in the code or want to test out the sandbox, you can check out the project here:

Live Platform: https://jedcorp.ink

I’d love to hear your thoughts, feedback on the agent execution pipeline, or how you handle process safety when running arbitrary security tools via LLMs! Let's chat in the comments below. 👇