EdgeAI Forge

A local-first, human-governed Physical AI engineering platform for industrial vision, robotics, ROS 2, PLC integration, and edge deployment.

EdgeAI Forge explores how specialized AI agents, local language models, edge compute, engineering tools, and industrial hardware can work together in one repeatable workflow:

Requirement -> Plan -> Generate -> Test -> Benchmark -> Optimize -> Review -> Deploy -> Monitor -> Learn

The platform is designed to keep private and latency-sensitive work on premises, while leaving room for optional cloud-model escalation when a task requires deeper reasoning or a larger context window.

The diagram represents the target architecture. The repository is currently an early-stage prototype: core APIs, the command-center dashboard, Docker infrastructure, a local Ollama client, and a three-agent proof of concept are present; several industrial agents and deployment workflows remain scaffolds or roadmap items.

Why EdgeAI Forge?

Industrial AI has requirements that are different from a general-purpose cloud chatbot:

• low-latency and offline-capable inference;
• control over sensitive images, telemetry, and engineering data;
• integration with cameras, robots, PLCs, ROS 2, and NVIDIA Jetson devices;
• reproducible testing, benchmarking, observability, and deployment;
• deterministic workflow boundaries and traceable artifacts; and
• mandatory human approval before safety-critical actions.

EdgeAI Forge is intended to become the engineering control plane for those workflows—not an autonomous replacement for engineering review or industrial safety systems.

Current implementation

Area	What is available now	Maturity
API gateway	FastAPI health, readiness, task-routing, command-center, and SSE endpoints	Prototype
Command center	Next.js 16 dashboard with React Query, backend proxying, SSE events, and mock fallback	Prototype
Local agent flow	Planner, Vision, and ROS agents calling Ollama through an asynchronous model gateway	Working proof of concept
Orchestration	Sequential three-agent runner in edgeai-forge; graph and queue interfaces in edge-ai-os	Proof of concept / stubs
Platform services	Docker Compose definitions for PostgreSQL, Redis, ChromaDB, Ollama, Prometheus, Grafana, Loki, and OpenTelemetry	Scaffolded
Memory and model routing	Typed module boundaries with placeholder implementations in edge-ai-os	Stub
Industrial modules	ROS, robotics, vision, PLC, automation, deployment, and agent design documentation	Planned / scaffolded
Benchmarks	Initial latency, FPS, and NVIDIA GPU-monitor scripts	Placeholder utilities

The command-center metrics and event data are currently demonstrative. They should not be interpreted as live production telemetry.

Architecture

The target deployment uses two logical nodes connected to edge and industrial systems:

Node	Role	Intended responsibilities
orion	Control plane / agent brain	FastAPI, agent orchestration, task state, memory, databases, dashboard, automation, and observability
atlas	AI compute / model runtime	Ollama, vLLM, TensorRT, vision and multimodal models, CUDA workloads, ROS 2, and inference APIs

The system is organized into four layers:

1. Developer and operator interfaces — VS Code, API clients, the web dashboard, and monitoring tools.
2. Control plane — task intake, routing, specialized agents, memory, artifacts, workflow state, and approval gates.
3. Compute plane — local LLM/VLM inference, vision and robotics models, model storage, and GPU acceleration.
4. Physical edge — Jetson devices, cameras, sensors, robots, PLCs, HMI/SCADA systems, and industrial I/O.

Local execution is the default design principle. Cloud providers are optional extensions and are not used by the current agent proof of concept.

Repository layout

.
|-- readme.md                         # Repository overview
|-- ChatGPT Image Jul 1, ... .png     # High-level architecture diagram
|-- EDGEAI_FORGE_SETUP_README.md      # Detailed two-node setup and build guide
|-- edge-ai-os/                       # Primary platform and dashboard scaffold
|   |-- api/gateway/                  # FastAPI control-plane API
|   |-- dashboard/ui/                 # Next.js operator command center
|   |-- agents/                       # Agent contracts, docs, and template service
|   |-- orchestrator/                 # Routing, graph, and task-manager stubs
|   |-- model_gateway/                # Local/cloud routing interfaces
|   |-- memory/                       # Project, vector, and lesson-memory interfaces
|   |-- benchmarks/                   # Latency, FPS, and GPU utilities
|   |-- infra/                        # Node and observability configuration
|   |-- deployment/                   # Docker, Jetson, and systemd guidance
|   `-- docs/                         # Architecture, contracts, and setup notes
`-- edgeai-forge/                     # Minimal Ollama-backed agent proof of concept
    |-- api/                           # FastAPI task API
    |-- agents/                        # Planner, Vision, and ROS agents
    |-- model_gateway/                 # Ollama client and task-to-model router
    |-- orchestrator/                  # Sequential agent coordinator
    `-- infra/docker/                  # API container image

Choose a runnable path

Goal	Start here
Run the dashboard, gateway, databases, and observability stack	edge-ai-os
Send a task through Planner, Vision, and ROS agents using Ollama	edgeai-forge
Reproduce the intended two-node orion / atlas setup	EDGEAI_FORGE_SETUP_README.md

Prerequisites

• Git
• Docker Engine or Docker Desktop with Docker Compose v2
• At least 8 GB of free memory for the infrastructure stack; more is recommended
• NVIDIA drivers and NVIDIA Container Toolkit only when using GPU-backed local inference
• An Ollama endpoint and the required models for the agent proof of concept

The project follows a Docker-first approach. Keep application dependencies inside containers and never commit .env files, credentials, model weights, datasets, or generated artifacts.

Quick start: platform and dashboard

From the workspace root:

cd edge-ai-os
cp .env.example .env
docker compose --profile infra up -d --build

On PowerShell, replace the copy command with:

Copy-Item .env.example .env

The infrastructure profile exposes:

Service	Default URL
Command-center dashboard	http://localhost:3001
FastAPI gateway	http://localhost:8000
Interactive API documentation	http://localhost:8000/docs
ChromaDB	http://localhost:8001
Grafana	http://localhost:3000
Prometheus	http://localhost:9090
Loki	http://localhost:3100

Verify the gateway:

curl http://localhost:8000/health
curl -X POST http://localhost:8000/gateway/route \
  -H "Content-Type: application/json" \
  -d '{"task":"build-ros-pipeline","payload":{"camera":"usb"}}'

Start the optional Ollama service alongside the infrastructure profile:

docker compose --profile infra --profile inference up -d --build
docker compose --profile inference exec ollama ollama pull qwen2.5-coder:7b
docker compose --profile inference exec ollama ollama pull llama3.1:8b

The /ready endpoint checks connectivity to the configured OLLAMA_HOST; it returns 503 when Ollama is unavailable even if /health is healthy.

Stop the stack with:

docker compose --profile infra --profile inference down

Quick start: local agent proof of concept

The smaller edgeai-forge application accepts one engineering task and sends it sequentially to the Planner, Vision, and ROS agents. All three agents currently use a local Ollama endpoint.

1. Prepare the environment file:

   cd edgeai-forge
   cp .env.example .env

2. Set LOCAL_LLM_BASE_URL in .env to a reachable Ollama server. The default is http://atlas:11434.

3. Ensure these models are available on that server:

   ollama pull qwen2.5-coder:7b
   ollama pull llama3.1:8b

4. Build and start the API and supporting services:

   docker compose up -d --build

5. Verify the API and submit a task:

   curl http://localhost:8080/health
   
   curl -X POST http://localhost:8080/task \
     -H "Content-Type: application/json" \
     -d '{"task":"Build a ROS 2 vision pipeline for USB-camera object detection and prepare it for Jetson Orin."}'

The task response contains separate plan, vision, and ros results. A slow response is expected because the current orchestrator waits for three model calls in sequence.

API summary

edge-ai-os gateway (localhost:8000)

Method	Route	Purpose
GET	/health	Process-level health check
GET	/ready	Ollama connectivity check
GET	/dashboard/command-center	Demonstration command-center snapshot
GET	/events/stream	Server-sent demonstration events
POST	/gateway/route	Accept a task and return the selected route

edgeai-forge proof of concept (localhost:8080)

Method	Route	Purpose
GET	/	Application metadata
GET	/health	API health check
POST	/task	Run Planner, Vision, and ROS model prompts

Development and verification

Run the gateway tests in a disposable container so Python dependencies do not modify the host:

cd edge-ai-os/api/gateway
docker run --rm \
  -v "$(pwd):/workspace" \
  -w /workspace \
  python:3.13-slim \
  sh -c "pip install --no-cache-dir -r requirements.txt pytest && python -m pytest -q"

Validate Compose and build the gateway and dashboard images:

cd edge-ai-os
docker compose config
docker compose --profile infra build api-gateway dashboard

The dashboard image runs npm ci and npm run build in its build stages. See the component guide for the optional local Next.js development workflow.

Engineering and safety principles

• Local first: keep frequent, private, and low-latency work on premises.
• Cloud optional: escalate only when explicitly enabled and justified.
• Human in the loop: require review before any production or hardware action.
• Simulation before motion: validate robotics behavior in simulation or dry-run mode.
• Never bypass interlocks: AI-generated logic is not a substitute for certified safety controls.
• Trace everything: retain task inputs, generated artifacts, test results, approvals, and deployment logs.
• Fail safely: no agent should automatically deploy to robots, PLCs, Jetson devices, or production systems.

Roadmap

• Replace the sequential proof of concept with a stateful LangGraph workflow.
• Persist tasks and artifacts in PostgreSQL; connect project memory to ChromaDB.
• Add retries, evaluation, audit logs, and human approval checkpoints.
• Convert dashboard placeholders into live architecture, workflow, model, memory, and deployment views.
• Implement ROS 2 package and launch-file generation with automated tests.
• Add vision training, export, TensorRT optimization, and real performance benchmarks.
• Build simulation-first robotics and reviewed Jetson deployment workflows.
• Add guarded Modbus and OPC UA integration templates.
• Introduce policy-driven cloud fallback without weakening local-only controls.

Documentation

• Detailed setup guide
• Platform overview
• Environment setup
• API contracts
• Development rules
• Node responsibilities
• Dashboard guide

Project status

EdgeAI Forge is under active development and is not production-ready. Generated robotics, PLC, machine-control, and deployment artifacts must be reviewed, tested, and approved by qualified engineers before use with real equipment.