Arachnia is an AI-driven multi-model development environment — a native, GPU-accelerated application built in Rust with direct integration across all major LLM inference providers. It is designed as a unified workspace where AI models have full awareness of your codebase, can collaborate alongside you in real time, and can propose, validate, and evolve code autonomously under your explicit review.

The AI layer is the core of the product. Silk Cortex provides streaming multi-provider chat with persistent memory context injected from the Resonance Weave recall ledger. Hivemind broadcasts a single prompt to N providers simultaneously for side-by-side comparative scoring and model evaluation. Every provider — Anthropic, OpenAI, xAI, Gemini, or a local Ollama model — routes through a single interface with no context switching.

Supporting intelligence is provided by the Spiderling analysis layer — concurrent per-file workers that surface severity-ranked findings and feed them directly into AI context — and the Venom Suite, which combines AI-driven code transformation (Venom Lattice), adversarial security payload generation (Venom), tree-sitter structural editing (AST Surgeon), and a multi-AI sandboxed build tournament (Evolution Engine).

Arachnia Live Session is the collaborative layer — a two-party real-time co-development protocol that synchronizes editor state, ghost cursor, selection range, open tabs, typed AI memory entries, and peer chat through the relay at arachnia.stream:8473. Two developers share one codebase, one AI context, and one conversation thread simultaneously, with every spiderling finding and terminal event crossing to the peer as structured memory.

Arachnia is structured as cooperating intelligence layers. Each layer is independent at runtime, communicating through shared application state rather than direct coupling. The rendering pipeline is single-threaded egui; all AI calls and analysis workers run on async or OS thread pools outside the render loop. Idle CPU usage is 0%.

Core capabilities organized by surface area. Every feature is compiled into the binary — no extensions, no plugin system, no network calls at startup.

Each module is a Rust source file that owns its rendering, state, and logic. Modules communicate through shared application state — no inter-module method calls across boundaries.

Configure API keys in settings. All routing is local — keys are never transmitted to the relay.

Arachnia Live Session is a two-party collaboration protocol built on the public relay at arachnia.stream:8473. One peer hosts by generating a token; the second joins by entering it. The relay carries all sync payloads in memory — no data is written to disk. Sessions auto-expire after 90 seconds of inactivity. No account, authentication, or configuration required beyond the token.

Session Lifecycle

The sync loop runs on a 2-second cycle. A FlushGate serializes push and pull operations — if a push is in-flight, the next pull is deferred until the push completes. This prevents cache corruption when the same author writes and reads within the same cycle window. Both roles (Live and Joined) push and pull symmetrically.

Editor State Fields

Synchronized each cycle via /session/push and /session/pull:

Memory Entry Kinds

Memory entries are pushed via /session/memory/push and pulled via /session/memory/pull, which returns entries merged from all authors, sorted ascending by timestamp. Each entry carries a typed kind field that controls how it is handled on receipt:

Auto-push Triggers

Memory is pushed on a 30-second cooldown, but certain workspace events bypass the cooldown and trigger an immediate push:

Rate Limits and Caps

JSON over HTTP. Tokens normalized to uppercase. Sessions expire after 90s idle. Rate limit: 5 creates/min per IP.