AI Surface
Competitive-Strong
Multi-provider orchestration, agentic tool loops, and local-model routing are already deeper than a normal editor baseline.
Overview
#overview
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 https://relay.arachnia.stream.
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.
Platform: Windows x86_64 (native GPU, DirectX). Hardware-accelerated renderer.
Idle CPU target: 0%. Cold start target: ≤200ms.
No runtime dependencies — single-file deployment.
Update Plans
#update-plans
Live roadmap workbench for the Markdown planning documents that move with the project. Open plans fast from the quick picker, then expand the full catalog only when you need side-by-side review.
Source docs stay in docs/. Run the publish script to sync and deploy.
Executive Summary
Arachnia currently reads strongest as a security-aware AI engineering workstation rather than a generic editor clone.
The public benchmark sheet now leads with explicit posture, evidence bands, and where the system is still experimental. Open the broader benchmark or the security-only assessment directly in the primary viewer, then expand the full workbench only when you need deeper side-by-side review.
Security Suite
Strong
Spiderlings, Venom, guardrails, and export/report flows give the product a credible built-in AppSec identity.
Prompt Efficiency
Strong
Token budgets, compaction, overflow artifacts, and helper routing are treated as first-class engineering controls.
Main Constraint
Architecture Drag
The biggest current risk is still ownership fragmentation across storage, tool orchestration, and telemetry contracts.
Compact mode hides the catalog and markdown viewers while keeping the assessment launch controls visible above the fold.
Loading plans...
Plan Catalog
Loading registered update plans...
The manifest at
plans/manifest.json populates this section.The primary viewer loads when a plan card is selected.
Primary Viewer
Awaiting catalog
Choose a plan from the catalog or dropdown.
Loading primary viewer...
Compare Viewer
Select a plan from the dropdown above.
The live site mirrors only the files registered in
plans/manifest.json.
Edit the source Markdown in docs/, then use
deploy-www.ps1 to sync and publish in one step.
Compact mode is active. Use the assessment buttons above to open a document or select Show Workbench Window to restore the full catalog and viewers.
Architecture
#architecture
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 AI PIPELINE
--------------------------------------------------------------------
User Input --> Silk Cortex --> Provider Router
|
+--------------------+--------------------+
v v v
Cloud APIs Ollama Hivemind
(Anthropic / OpenAI (local host) (N providers,
xAI / Gemini) parallel)
+--------------------+--------------------+
|
v
Streaming Token Assembly
|
v
Resonance Weave --> Recall Ledger
(insight extraction) (injected as system
context, next query)
ANALYSIS LAYER
--------------------------------------------------------------------
Workspace --> Spiderling Workers (concurrent, per-file)
|
v
Severity-ranked Findings + Amber Semantic Index
| (embedding search)
v
Collab Memory Push --> Peer AI Context
MUTATION LAYER (Venom Suite)
--------------------------------------------------------------------
Venom Lattice --> AI diff proposals --> Accept / Reject
Venom --> Adversarial payloads (network-blocked sandbox,
constrained execution environment)
Evolution Eng. --> Multi-AI changeset candidates
|
Isolated Sandbox (fast incremental builds)
|
Scoring tiers:
Tier 0 -- build gate (compile pass/fail)
Tier 1 -- static delta (pub_fn, warnings)
Tier 2 -- AI judge (LLM qualitative)
|
Ranked candidates --> Human review + confirm
AST Surgeon --> Tree-sitter structural edits (direct, no diff)
COLLABORATION LAYER (Arachnia Live Session)
--------------------------------------------------------------------
Editor state --> Sync Gate --> Relay (https://relay.arachnia.stream)
|
Bidirectional sync (periodic cycle):
editor content + file path
cursor position (line, col)
selection range (start / end line+col)
open tab list
peer chat (chat_message entries)
memory entries (6 typed kinds)
spiderling findings (on analysis complete)
terminal output (on command exit)
|
Ghost cursor badge in peer editor gutter
Translucent ghost selection overlay
Tab bar: dim-o peer-open, lit-dot peer-editing
VISUALIZATION LAYER
--------------------------------------------------------------------
NeuralWeave --> Force-directed dependency graph (on-demand)
AI-annotated weak strands: fan-out, circular, dead
Consciousness --> System + model health sphere
VibeCanvas --> Freeform node-graph workspace
Features
#features
Core capabilities organized by surface area. Every feature is compiled into the binary — no extensions, no plugin system, no network calls at startup.
| Area | Capability |
|---|---|
| AI Chat | Streaming multi-provider chat: Anthropic, OpenAI, xAI, Gemini, and Ollama local models unified in one interface. Resonance memory context injected automatically. Configurable temperature, max-tokens, and system prompt per session. Markdown response rendering. |
| Multi-model | Hivemind: broadcast a single prompt to N providers concurrently, responses rendered side-by-side with hybrid comparative scoring. Latency, quality tier, and model-specific telemetry tracked per response with optimization rules that evolve as patterns emerge. |
| Editor | Multi-tab with syntax highlighting, per-tab undo history, indent rainbow tints, error lens inline diagnostics, ghost cursor badge + translucent ghost selection overlay for the collab peer, Ctrl+K inline AI palette at cursor. |
| Analysis | Concurrent Spiderling workers per file, severity-ranked findings (error / warning / hint / info), live sync to collab peer on analysis completion, Amber embedding-based semantic search and grounded recall across the full workspace. |
| Mutations | Venom Lattice: AI-driven transformation proposals as structured diffs, per-change accept/reject. AST Surgeon: tree-sitter structural edits (rename symbol, extract function, inline variable) operating on the parsed AST, not raw text. |
| Evolution | Evolution Engine: multi-AI sandboxed build tournament. Candidates compiled in an isolated sandbox (fast incremental builds), scored on three tiers (build gate / static delta / AI judge), ranked in Evolution Ledger. Persistent cross-session snapshot memory. Human review required before any change merges. |
| Security | Venom adversarial security suite: generates concrete attack payloads in a network-blocked, sandboxed environment. Execution is fully isolated from the live workspace. All payloads are surfaced as reviewable artifacts, never auto-applied. |
| Memory | Resonance Weave extracts typed insights from conversations into a persistent recall ledger injected as grounded system context on future queries. Memory entries are shared across collab sessions via relay. Amber semantic index enables embedding-based recall. |
| Collaboration | Arachnia Live Session: bidirectional editor sync, ghost cursor and selection range, open tab list, peer chat cross-talk, 6-kind typed memory sync (insight / chat_message / terminal / spiderling / edit_pattern / warning), serialized push/pull sync gate, heartbeat-based auto-disconnect. |
| Terminal | Integrated terminal with command monitoring. Exit codes and recent output automatically create collab memory entries (terminal kind) on command completion, injected into both peers' AI context. |
| Visualization | NeuralWeave: force-directed live dependency graph with AI-annotated weak strands (high fan-out, circular deps, dead code), manual Cast Web trigger (zero idle CPU), four sub-tabs. Consciousness health sphere. VibeCanvas freeform node workspace. |
| Planning | AI-driven task decomposition. Goal → executable step tree with sub-tasks, dependencies, and status tracking. Plans persist per workspace in the project config directory. |
Modules
20 modules
#modules
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.
◈Silk Cortex
Primary AI chat interface. Manages conversation history, provider dispatch, streaming token assembly, Resonance memory context injection, and markdown response rendering. The central user-facing AI surface.
≈NeuralWeave
Live dependency graph visualization. Force-directed spider-web layout maps every file and function to a node; import chains render as weighted threads. AI annotates "weak strands" — high fan-out, circular dependencies, dead code. Triggered manually ("Cast Web") — zero idle CPU. Sub-tabs: Graph, Details, Resonance, Mind. Collab-aware when a session is active.
⌇Spiderlings
Autonomous workspace analysis swarm. Concurrent per-file workers surface severity-ranked findings. New findings push automatically to the collab peer as structured memory entries via the relay.
⬡Venom Lattice
AI code transformation engine. Presents mutation proposals as structured diffs with per-change accept/reject controls. Accepted mutations write to disk; rejected patterns feed back into future proposal framing.
⚠Venom
Adversarial security testing suite. Generates concrete attack payloads in a network-blocked sandbox with a multi-layered constraint system. All executions are fully isolated from the live workspace. Payloads surface as reviewable artifacts only.
⟳Evolution Engine
Multi-AI sandboxed build tournament. Models propose code changes as concrete changesets; each candidate is compiled in an isolated sandbox (fast incremental builds), scored on three tiers, and ranked in the Evolution Ledger. Persistent cross-session snapshot storage remembers which patterns survived. Human review required before merge.
⩛Scoring
Hybrid tiered evaluation for Evolution Engine candidates. Tier 0: build gate (compile pass/fail). Tier 1: static delta analysis — pub_fn count, build warnings, complexity delta. Tier 2: optional AI judge via LLM prompt for qualitative scoring. Blended score from configurable tier weights via JudgeReport.
∿Resonance Weave
Persistent AI memory layer. Extracts structured typed insights from chat history into a recall ledger. Injected as grounded system context on future queries. Survives process restart. Memory entries shared cross-session via relay.
∆Hivemind
Multi-model coordination panel. Broadcasts a single prompt to N providers concurrently. Responses rendered side-by-side with hybrid comparative scoring — latency, quality tier, and model-specific telemetry. Optimization rules injected as model behavior evolves.
◉Amber
Semantic workspace search. Embedding-based fuzzy matching across all files. Results ranked by semantic distance with inline context preview. Powers grounded AI responses when querying about specific code constructs or intent.
✦AST Surgeon
Tree-sitter structural code editing. Operates on the parsed AST rather than raw text — rename symbol, extract function, inline variable, reorder parameters. Changes previewed as diffs before application. Language-aware, not pattern-matching.
≡Planner
AI-driven task decomposition. Accepts a goal statement and produces an executable step tree with sub-tasks, dependencies, and status tracking. Persisted per workspace in the project config directory.
▦Vibe Canvas
Freeform visual workspace. Structural sketching and node-graph idea mapping with AI prompt invocation on individual canvas elements. Free-form and grid-snapped placement modes.
⊿Resource Budget
Local inference budget tracking. OllamaModelManager auto-detects installed models and their memory footprint. LocalInferenceBudget enforces configurable peak RSS ceilings with warnings at 80% and hard block at 100% capacity.
┤Editor
Multi-tab code editor. Syntax highlighting, per-tab undo history, indent rainbow tints, error lens inline diagnostics, ghost cursor badge and translucent ghost selection overlay for the collab peer. Ctrl+K inline AI palette.
$_Terminal
Integrated terminal with command monitoring. Exit codes and recent output automatically create collab memory entries (terminal kind) on command completion, visible in both peers' AI context.
⥱Collab
Arachnia Live Session coordination. Manages relay connection state, sync gate push/pull serialization, memory sync, peer chat, ghost cursor and selection rendering, tab bar indicators, and session lifecycle (Live / Joined / auto-disconnect on heartbeat timeout).
⊞Explorer
File system browser. Directory tree with lazy expansion and file operations: create, rename, delete, drag to editor tab bar.
◷Consciousness
System awareness layer. Tracks AI model availability, workspace health signals, resource budget counters, Ollama process state, and surfaces operational alerts in the status overlay.
○Profiles
User identity management. Author name used for collab attribution — displayed in ghost cursor overlay, memory entry headers, and peer chat messages.
MCP Tools
38+ tools
#mcp-tools
Arachnia exposes 38+ built-in tools to every AI model through a unified tool interface. Each tool has a canonical ID, description, and prompt hint injected into the LLM system prompt at conversation start. Tools are grouped by capability domain and filtered per subsystem — Spiderlings and Venom receive a restricted subset appropriate to their role.
Core IDE Tools
| Tool | Capability |
|---|---|
| Codebase Search | Regex and semantic search across the entire workspace with ranked results |
| File Read / Edit / Create | Direct file system operations with structured diff previews and undo tracking |
| List Directory | Recursive directory tree with depth control |
| Terminal Run | Command execution with output capture, exit code reporting, and collab memory push |
| Error Lens | Inline compiler diagnostics forwarded to AI context for targeted fix suggestions |
Language Intelligence
| Tool | Capability |
|---|---|
| Rust Analyzer | Deep Rust intelligence — borrow checker explanations, trait resolution, lifetime analysis, clippy integration |
| C/C++ IntelliSense | Compilation analysis, header resolution, memory safety auditing |
| Python Environments | venv, conda, and pyenv management per terminal tab — isolated interpreter routing |
| AST Surgeon | Tree-sitter structural refactoring: rename across files, extract/inline functions, change signatures with automatic call-site cascade, module moves |
| Refactor Choreographer | Multi-step atomic refactoring plans with automatic rollback on any step failure |
Analysis & Security
| Tool | Capability |
|---|---|
| Code Review | Automated review with severity-ranked findings and inline annotation |
| Security Audit | OWASP Top 10 coverage — injection, auth bypass, data exposure, SSRF, crypto weakness, dependency CVEs |
| Property Verifier | proptest/hypothesis-based property testing with automated counterexample finding |
| Dependency Advisor | Transitive closure analysis, size impact, license audit, maintenance status evaluation |
Execution & Verification
| Tool | Capability |
|---|---|
| Execution Probe | Sandboxed snippet runner — Python, JS/TS, Rust, Shell, PowerShell. Timeout-enforced, ephemeral execution environment. Two-step compile+run for compiled languages. |
| Verify Build | Auto-detects build system (cargo, npm, make, python) and runs the appropriate build command |
| Run Tests | Test execution with structured pass/fail reporting and failure context extraction |
| Live Server | Local development HTTP server with live-reload for web projects |
Documentation & Intelligence
| Tool | Capability |
|---|---|
| Doc Oracle | Fetches structured API documentation from crates.io, PyPI, npm, MDN, and Rust stdlib. sled-backed response cache — zero repeated network requests. |
| Web Fetch | Targeted web content retrieval with HTML-to-text extraction |
| Multimodal Vision | Image and screenshot analysis for vision-capable models |
| Spell Checker | camelCase and snake_case aware spell checking across identifiers and comments |
Workflow & Automation
| Tool | Capability |
|---|---|
| Enter/Exit Plan Mode | Read-only exploration mode — AI can inspect codebase without modifying files |
| Todo Write | Live task list widget with status tracking, updated in real-time during agent execution |
| Git Context / Worktree | Branch state, diff summary, parallel branch isolation via git worktrees |
| Cron Create/List/Delete | Scheduled background tasks with configurable intervals (60s–86400s) |
| Monitor / Check Monitor | Background file and process watch tasks with event-driven notifications |
| Remote SSH | Key management, tunnel creation, and file transfer over SSH |
| Config Read/Write | Application settings access with security-gated keys — sensitive values are write-only |
MCP Infrastructure: External tools connect via JSON-RPC 2.0.
tools/list discovery, per-tool enable/disable, and
context compression that trims tool results before re-injection into the conversation.
Forge Build Server
#forge
Forge is a standalone Rust build server that
ships as two binaries: a visual GUI (forge) and
a headless MCP server (forge-mcp). The MCP server
is auto-registered by Arachnia at startup — the AI can start, monitor, and cancel
builds without the user touching a terminal.
MCP Build Tools
| Tool | Behavior |
|---|---|
| build_start | Start a build and return a build_id immediately. Accepts project path, profile (dev/release/custom), action (build/check/test/run/clean/clippy), target binary, feature flags, and extra args. Optional CPU boost mode activates the Windows High Performance power plan for the duration of the build. |
| build_status | Non-blocking progress poll. Returns current state — crates compiled / total, current crate name, elapsed time, errors and warnings collected so far — without waiting for completion. |
| build_result | Blocks until the build completes, then returns the full result with a Markdown-formatted summary. Zero polling tokens wasted — designed for LLM consumption. Configurable max_diagnostics truncation. |
| build_cancel | Cancel a running build by ID. Terminates the build process and frees the build slot. Concurrent build slots are limited. |
Build Engine
The build engine discovers project metadata by walking up from a path to find
Cargo.toml.
Parses profiles, features, default features, and binary targets for accurate
progress reporting.
Builds execute asynchronously, emitting structured diagnostics with file, line, column, and severity. Build state streams in real-time: crates compiled, current crate, errors, warnings, elapsed time, exit code, and binary output path.
FORGE ARCHITECTURE
--------------------------------------------------------------------
AI Tool Call --> forge-mcp (JSON-RPC 2.0, auto-registered)
|
Build Engine --> Structured progress stream
| |
build_status (poll) build_result (block)
|
Power Plan management
High Performance ON during build
Previous plan restored on completion
Integration: Arachnia auto-locates
forge-mcp.exe as a sibling to the main binary.
Spawned headlessly with suppressed window and output. Port registered automatically
at startup — no manual configuration required.
Binary Intelligence
#binary-intel
The AI can analyze compiled binaries — .exe,
.dll, ELF, Mach-O — as a first-class tool.
A local Binary Analysis MCP server runs locally
and is registered automatically at startup. Seven tools expose static analysis,
disassembly, classification, and semantic search over binary code.
Analysis Tools
| Tool | Capability | Mode |
|---|---|---|
| binary_analyze | Full static analysis — PE/ELF/Mach-O headers, sections with per-section entropy, import/export tables, suspicious pattern flags, packing heuristic (entropy > 7.2), SHA-256 hash, overall risk score | READ |
| binary_decompile | Capstone-based disassembly — accepts hex bytes or file path + function name. x86_64, ARM64, RISC-V. Up to 2048 instructions per function. | READ |
| asm_to_ir | Normalizes architecture-specific assembly to architecture-independent IR. Registers renamed to logical roles (arg0–arg7, ret, sp, fp), hex immediates become IMM. Enables cross-architecture comparison. |
READ |
| binary_classify | Heuristic risk classification: benign / suspicious / malicious. Scores section entropy, suspicious imports (VirtualAllocEx, CreateRemoteThread), shellcode signatures, packing indicators. Returns verdict, confidence, risk score 0–100, and reasons. |
READ |
| binary_embed | Compute a dense embedding vector for any code, ASM, or IR text using the tiered embedding backend. Returns backend tier, model name, dimension, and vector. | READ |
| binary_search_similar | Embed a code or ASM snippet and find top-k most similar functions in the local datasheet via cosine similarity. Recognizes compiler patterns, known algorithms, and obfuscated variants. | READ |
| binary_build_sheet | Long-running pipeline: extract all functions from a binary, disassemble each, normalize to IR, compute embeddings, and upsert into the local datasheet. Stored persistently in the app-managed binary data store. | WRITE |
Tiered Embedding Backend
Graceful degradation — the embedding engine probes available backends at startup and selects the highest-quality tier available. All vectors are L2-normalized.
| Tier | Backend | Details |
|---|---|---|
| 1 | Ollama (local) | Probes locally installed embedding models in priority order. Zero external traffic. |
| 2 | HuggingFace | High-quality sentence-transformer model via local inference. Native batch encoding with L2 normalization. |
| 3 | OpenAI-compatible API | Configurable via environment variables. Falls back to a standard text embedding model. |
| 4 | TF-IDF fallback | Sparse token-hash embedding. Mnemonic-first tokenization for ASM/IR text. Always available, zero external dependencies. |
Alias Resolution
The tool normalizer maps dozens of natural language variants to canonical tool IDs.
“decompile”,
“pseudo_code”,
“bin_decompile” all route to
binary_decompile.
“malware_check” routes to
binary_classify.
Models never need to guess the exact canonical name.
Analysis engine: Multi-format binary parsing (PE/ELF/Mach-O),
multi-architecture disassembly (x86_64, ARM64, RISC-V), optional IR extraction.
All file paths validated against the workspace root before access — no path traversal.
File size, function count, and execution time caps enforced.
Keyboard Shortcuts
#shortcuts
| Binding | Action |
|---|---|
| Ctrl+K | AI command palette — inline prompt at cursor position |
| Ctrl+Shift+Z | Semantic undo history — AI-aware snapshot time-travel |
| Ctrl+P | Quick open file — fuzzy search across workspace |
| Ctrl+S | Save current file |
| Ctrl+, | Open settings panel |
| Ctrl+= / Ctrl+- | Zoom in / zoom out |
| Ctrl+0 | Reset zoom to 100% |
| Ctrl+Shift+I | Switch to IDE Mode |
| Ctrl+Shift+V | Switch to Vibe Mode |
| Ctrl+Shift+J | Toggle Zen sub-mode (Vibe Mode only) |
AI Providers
#providers
Configure API keys in settings. All routing is local — keys are never transmitted to the relay.
| Provider | Models | Endpoint |
|---|---|---|
| Anthropic | claude-opus-4 claude-sonnet-4-5 claude-haiku-3-5 | api.anthropic.com |
| OpenAI | gpt-4o o3 o4-mini | api.openai.com |
| xAI | grok-3 | api.x.ai |
| gemini-2.5-pro gemini-2.0-flash | generativelanguage.googleapis.com | |
| Ollama | any local model | local inference host |
Ollama models are auto-detected on startup via the local model discovery API.
The model list populates without manual configuration. No API key required.
Collab Protocol
#collab
Arachnia Live Session is a two-party collaboration protocol built on the public relay
at https://relay.arachnia.stream. 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
Host: Idle --> Generate Token --> Live(token) --> Syncing
Guest: Idle --> Enter Token --> Joined(token) --> Syncing
|
Both: ...................................... Auto-disconnect at 60s heartbeat timeout
Token freed, relay slot removed, UI resets to Idle
The sync loop runs on a periodic cycle. A sync gate 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:
| Field | Description |
|---|---|
| file_path | Active file path — peer editor navigates to matching file automatically on receipt |
| content | Full file content — applied as a non-destructive content patch if the file is already open |
| cursor_line, cursor_col | Cursor position — rendered as a labelled ghost cursor badge in the peer's editor gutter |
| sel_start_line / sel_start_col | Selection start — lower bound of the ghost selection overlay rendered in peer's editor |
| sel_end_line / sel_end_col | Selection end — upper bound, rendered as a translucent tinted block over the peer's text |
| tabs | Open tab filenames — dim ○ in tab bar when peer has file open, ● when peer is actively editing it |
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:
| kind | Source | Effect on peer |
|---|---|---|
| insight | Resonance Weave extraction | Injected into AI system context as grounded workspace knowledge on the next query |
| chat_message | Collab overlay input field | Appears as cross-talk in peer's collab panel; displayed with author attribution and timestamp |
| terminal | Terminal command completion | Last 40 lines of output + exit code injected as AI context; shown as system message in chat view |
| spiderling | Analysis worker finding | Severity-ranked finding injected as AI context; visible in peer's findings panel with source location |
| edit_pattern | Accepted Venom mutation | Pattern recorded and used to influence framing of future Venom Lattice proposals for this codebase |
| warning | Venom Lattice alert | High-severity warning surfaced in peer's notification overlay immediately on next pull cycle |
Auto-push Triggers
Memory is pushed on a regular cooldown, but certain workspace events bypass the cooldown and trigger an immediate push:
File save + content change --> immediate push (edit_pattern)
Spiderling analysis complete --> push findings (spiderling kind)
Terminal command exits --> push output (terminal kind, recent output + exit code)
Venom warning generated --> push alert (warning kind)
Rate Limits and Caps
| Limit | Value | Notes |
|---|---|---|
| Session creates | 5 / min / IP | Enforced at relay, returns 429 on excess |
| Memory entries per author | Capped | Oldest entries evicted when cap reached |
| Session idle expiry | Auto | Measured from last push or heartbeat |
| Heartbeat timeout | Auto | Client-side: auto-disconnect and reset to Idle |
Relay API
#relay-api
JSON over HTTP. Tokens normalized to uppercase. Sessions expire after 90s idle. Rate limit: 5 creates/min per IP.
POST
/session/create
Register a new token. Body:
{"token":"ABC"}. Returns {"ok":true}.
POST
/session/join
Validate an existing token. 404 if not found or expired.
POST
/session/push
Store sync payload. Fields: token, file, content, cursor, cursor_col, sel_start_line, sel_start_col, sel_end_line, sel_end_col, tabs[].
GET
/session/pull?token=X
Fetch the latest stored payload. Returns empty sentinel if nothing pushed yet.
POST
/session/leave
Remove session immediately, freeing the relay slot.
POST
/session/memory/push
Push per-author typed memory entries. Body: token, author, entries[]. Replaces author's slot. Capped at 500 entries.
GET
/session/memory/pull?token=X
Return merged entries from all authors, sorted by timestamp ascending.
GET
/healthz
Liveness check. Returns
{"ok":true,"sessions":N}.
Remote Tunneling
#tunneling
Planned
Remote Access & WebRTC Tunneling
Reverse-tunnel support via arachnia.stream is in planning.
WebRTC peer connections, TURN relay at
This page will document the tunnel client, port forwarding, and connection commands.
WebRTC peer connections, TURN relay at
turn.arachnia.stream,
and SSH gateway are scoped for a future release.This page will document the tunnel client, port forwarding, and connection commands.
Download
#download
Planned
Binary Distribution
Signed Windows installer (.exe via Inno Setup) and portable binary are planned.
Build target: x86_64-pc-windows-msvc. Size budget: <12 MB binary.
Source remains private until the initial public release.
Build target: x86_64-pc-windows-msvc. Size budget: <12 MB binary.
Source remains private until the initial public release.