nafi@portfolio:~$
bash — ~/projects/arc-engine
$cd ~/projects/arc-engine && cat summary.txt
Python application for running automated coding and processing tasks via locally hosted AI models. Optimized for Intel Arc GPU hardware, bypassing commercial API rate limits and keeping all data private.

arc_engine

Systems Developer · #0f88c3d systems
Python · Local LLMs · Intel Arc GPU github.com/sleepyhead000
~/projects/arc-engine $

cat README.md

README.md
$cat overview.txt
arc_engine is a local-first automation framework that runs coding agents and data-processing pipelines entirely on-device. It leverages Intel Arc GPUs (Xe architecture) via IPEX-LLM and llama.cpp for accelerated inference, eliminating cloud API dependencies, rate limits, and data egress concerns.
$cat inference.txt
Supports GGUF-quantized models (4-bit through 8-bit) via llama.cpp Python bindings with IPEX-LLM backend for Intel GPU offload. Model loader auto-detects available VRAM, selects max context fitting in memory, and falls back to CPU offload layers when needed. Tested with CodeLlama-7B/13B, DeepSeek-Coder-6.7B, Phi-3-mini — all fit in 8-12GB VRAM at Q4_K_M.
$cat agents.txt
Agent runtime: task queue (SQLite-backed), sandboxed exec environment (subprocess with resource limits), structured prompt templates (Jinja2), and tool registry (file ops, shell, HTTP, Python REPL). Agents run asynchronously; results streamed via asyncio queues. Built-in retry with exponential backoff and max-attempt cap.
$cat privacy.txt
Zero telemetry. No outbound requests except explicit tool calls (HTTP tool). Model weights, context, and outputs never leave the machine. Configurable audit log (local SQLite) records prompt/response hashes for reproducibility without storing content. Suitable for proprietary codebases and sensitive data processing.
~/projects/arc-engine $

ls -l features/

inference
llama.cpp + IPEX-LLM · Intel Arc GPU offload · GGUF quantization support
models
CodeLlama, DeepSeek-Coder, Phi-3 · 4-8 bit GGUF · auto VRAM fit
runtime
Async task queue · sandboxed exec · tool registry · streaming results
privacy
Zero telemetry · local-only · audit log (hashes only) · no cloud deps
hardware
Intel Arc GPU (A750/A770) · CPU fallback · multi-GPU aware
interface
CLI + REST API · WebSocket streaming · JSON-RPC compatible
~/projects/arc-engine $

cat stack.yaml

language
Python 3.11+
inference
llama-cpp-python + IPEX-LLM (Intel GPU)
queue
SQLite (WAL) + apscheduler
async
asyncio · anyio (structured concurrency)
templates
Jinja2 (prompt templating)
api
FastAPI + Uvicorn (REST + WebSocket)
cli
Typer + Rich
~/projects/arc-engine $

git log --oneline

#1a2b3c4feat/ipex

IPEX-LLM integration for Intel Arc

Python · IPEX-LLM · llama.cpp
  • Auto-detects Arc GPU via SYCL device enumeration; selects Xe cores.
  • Model split: GPU layers = min(total_layers, VRAM_budget / layer_size).
  • Fallback chain: GPU → CPU offload → pure CPU (llama.cpp default).
#2b3c4d5feat/agent

Agent runtime with tool registry

Python · asyncio · Jinja2
  • Tools: file_read/write, shell_exec (timeout+mem limit), http_request, python_repl.
  • Prompt templates versioned in /prompts; rendered with task context.
  • Streaming token output via async generator; SSE endpoint for web clients.
#3c4d5e6feat/queue

Persistent task queue & scheduling

SQLite · APScheduler
  • Tasks stored with status (pending/running/done/failed), priority, retries.
  • Cron-style recurring jobs (e.g., nightly codebase analysis).
  • Dead-letter table for tasks exceeding max_retries; manual replay CLI.
#4d5e6f7feat/privacy

Privacy-first architecture & audit logging

SQLite · SHA-256
  • Zero outbound network by default; HTTP tool opt-in per task.
  • Audit log stores: timestamp, task_id, model_hash, prompt_hash, response_hash.
  • Content never written to disk; hashes enable reproducibility verification.
#5e6f7a8feat/api

REST + WebSocket API layer

FastAPI · Uvicorn · WebSocket
  • POST /tasks (submit), GET /tasks/{id} (status), WS /tasks/{id}/stream (tokens).
  • JSON-RPC 2.0 compatible endpoint for IDE plugin integration.
  • API key auth (optional); rate limiting per key via Redis (if present).