Foxforge

Self-hosted AI workspace. No API keys. No cloud. No subscriptions. No frontier model calls. Ever.

Foxforge is a local-only AI workspace for research, writing, and software generation. It routes requests through specialized multi-agent pipelines — each lane a coordinated team of models working in defined stages toward a quality-controlled output. Everything runs on your own hardware, on models you control, with data that never leaves your machine.

There is no external API integration and there never will be. The architecture is deliberately closed to frontier providers.

Why Foxforge

	Foxforge	Cloud AI assistants
Runs on	Your own hardware	Provider's servers
AI models	Any Ollama-compatible or llama.cpp model	Locked to provider
Your data	Stays on your machine — always	Sent to vendor
API keys	None required, none accepted	Required
Cost	Free after hardware setup	Ongoing subscription
Offline	Fully functional without internet	Requires connectivity
Customizable	Full source — fork and modify	Black box

---

Start Here (10 minutes)

Fresh clone

git clone https://github.com/GuideboardLabs/Foxforge.git
cd Foxforge

Linux (Ubuntu 24.04 / 22.04 LTS)

chmod +x install_foxforge_linux.sh
./install_foxforge_linux.sh

Then start the app:

sudo systemctl start foxforge
# or
./start_foxforge.sh

Windows

git clone https://github.com/GuideboardLabs/Foxforge.git
cd Foxforge
powershell -ExecutionPolicy Bypass -File .\install_foxforge.ps1
powershell -ExecutionPolicy Bypass -File .\start_foxforge_web.ps1

Open: http://127.0.0.1:5050

For recipient-friendly install steps, see INSTALL_GUIDE.md.

---

The Lanes

Foxforge routes every request through one of three top-level lanes. Each lane is a pipeline of specialized agents running local models in sequence — not a single prompt, not a single model.

---

Research Lane

Web and local evidence gathering, synthesis, and analysis. Powers the Fieldbook (web research) workflow.

Tree planner — a planner model (deepseek-r1:8b, think=True) decomposes the root question into a breadth/depth research tree. Leaves are assigned to the persona with the strongest affinity for that angle, so the four personas no longer fan out on identical questions.

Four personas execute leaves (2 concurrent by default):

Agent	Role	Model
Market Analyst	Market dynamics, alternatives, competitive positioning	qwen3:8b
Technical Researcher	Feasibility, bottlenecks, implementation constraints	deepseek-r1:8b (think=True)
Risk Researcher	Failure modes, mitigations, systemic constraints	deepseek-r1:8b (think=True)
Execution Planner	Practical sequencing, milestones, resources needed	qwen3:8b

Personas can hand off leaves to each other when a question sits outside their competence — loop prevention and a per-leaf handoff cap keep routing bounded.

Each agent applies evidence discipline: findings are labeled [E] (evidence-backed), [I] (inferred), or [S] (speculative). A self-check rates quality (1–5) before output. A gap assessment identifies what's missing. A final skeptic pass (deepseek-r1:8b) validates the full picture before synthesis.

Synthesizer — unifies all persona streams into a coherent narrative with cross-persona consistency validation.

Citation linker — post-processes synthesized text to anchor each sentence to the retrieved chunk that supports it; cosine-misaligned citations are dropped rather than passed through as fabrication.

Skeptic sidecar — the skeptic pass revises the publishable synthesis directly and writes its rationale to a separate *.critique.md sidecar file (linked in the artifact block when present).

Web research cache — repeat queries are served from a content-addressed SQLite cache with volatility-tiered TTL (24h general, 2h recency-sensitive, 10m live events).

Web foraging stack (optional, Docker): SearXNG + Crawl4AI for live web research.

Stack-decision guard — outside a technical topic, research requests that are purely stack-choice comparisons (for example SQLite vs Postgres, Flask vs FastAPI, Vue vs React) are short-circuited with guidance to re-run in a Technical topic.

---

Make Lane

Artifact generation. The Make lane covers seven distinct pools, each a purpose-built multi-agent pipeline for a specific class of deliverable.

All pools run entirely locally. No request touches a remote API.

---

Essay Pool

Short-to-medium documents: essays, reports, briefs.

Pipeline — 6 stages:

Outliner → Writers (≤3 parallel) → Critic → Revisor → Compositor → Proofreader

Stage	Agent	Model	Role
1	Outliner	qwen2.5:7b	Thesis and per-section structure
2	Writers	qwen3:8b	~400-word sections, parallel
3	Critic	deepseek-r1:8b	Flags gaps, repetition, drift
4	Revisor	qwen3:8b	Applies critic notes to flagged sections only
5	Compositor	qwen2.5:7b	Title, transitions, conclusion
6	Proofreader	deepseek-r1:8b	Fact contradictions, truncation, tense drift

Topic-aware templates adjust section structure automatically:

• history — Background → Key events → Historiographical debate
• science — Evidence review (RCT > observational > anecdotal) → Implications
• finance — Market context → Risk factors → Thesis & recommendation (not financial advice)
• medical — Clinical summary → Evidence tiers → Safety profile → Disclaimers (not medical advice)
• animal_care — Vet-reviewed evidence → Safety profile → Owner considerations
• politics — Policy context → Stakeholder analysis → Counter-arguments
• sports — Statistical analysis → Risk & uncertainty → Analysis & outlook
• underground — No restrictions; all agents route to unrestricted model
• technical, math, parenting, general — Domain-specific variants

Output targets:essay (full treatment), brief (skips critic/revision/proofreader), blog, social_post

Underground topics route every agent to huihui_ai/qwen3-abliterated:8b-Q4_K_M.

---

Longform Pool

Extended structured outputs: long-form essays, guides, tutorials, video scripts, newsletters, press releases.

Pipeline — 6 stages:

Planner → Writers (parallel) → Critic (think=True) → Revisor → Compositor → Quality Gate

Type-specific targets with word count enforcement:

Type	Word Range	Structure
essay_long	1,800–3,500	Hook → Argument pillars (3–5) → Steelman counterpoint → Synthesis
essay_short	400–900	Hook → Argument → Counterpoint → Close
guide	1,000–2,500	Prerequisites → Steps → Verification → Next steps
tutorial	1,200–3,000	Goal → Setup → Core logic → Integration → Troubleshooting
video_script	1,500–4,000	Hook (0–15s) → Premise → Beats → Turn/Reveal → CTA
newsletter	600–1,200	This Week → Worth Your Time → One Idea → Dessert
press_release	400–700	Headline → Dateline → Lede → Body → Boilerplate → Contact

Video scripts include [SEGMENT: name] and [B-ROLL: description] markers for production use.

Public-content guardrail: planner/compositor stages avoid personal specifics from profile hints (family, pets, health, workplace) unless the user explicitly asks for them.

Models:qwen3:8b (planner/writer/compositor), deepseek-r1:8b (critic, think=True). Upgrades to qwen2.5:32b + deepseek-r1:14b automatically when available.

---

Content Pool

Short-form, high-velocity content: blog posts, social posts, emails.

Pipeline — 6 stages:

Planner → Writers (≤3 parallel) → Critic (think=True) → Revisor → Compositor → Quality Gate

Type	Word Range	Notes
blog	600–800	Hook & headline → Context → Core (subheadings, examples) → CTA
social_post	80–220	Stop-scrolling hook → Body (2–3 lines) → CTA. Platform-aware voice.
email	200–400	Subject (<60 chars) → Front-loaded ask → Short body → Sign-off

Drafter and Polish agents use huihui_ai/qwen3-abliterated:8b-Q4_K_M for creative latitude. Critic uses deepseek-r1:8b. Integrates learned feedback from the FeedbackLearningEngine across prior Make runs.

Public-content guardrail: planner/compositor stages avoid personal specifics from profile hints (family, pets, health, workplace) unless the user explicitly asks for them.

---

Specialist Pool

Domain-expert deliverables requiring specialized validation with enforced quality gates.

Pipeline — 7 stages:

Outliner → Writers → Domain Critic (think=True) → Revisor → Compositor → Quality Gate

Supported domains:

Domain	Enforced Requirements
medical	Evidence tiers (RCT → observational → case study → opinion); safety profile; "not medical advice"
finance	Risk disclosures; assumption clarity; "not financial advice"
sports	Statistical claims with dates; injury/roster freshness notes
history	Source quality notes; historiographical balance; date/actor specificity
game_design_doc	Core loop clarity → Systems interlock → Scope feasibility → MVP vs. full vision

Quality Gate enforces minimum 1,500 character outputs for medical/finance/history, required disclaimer presence, and truncation rejection.

---

Creative Pool

Long-form creative writing: novels, memoirs, books, screenplays.

Pipeline — 5 stages:

Story Planner → Scene Writers (sequential, continuity-aware) → Voice Critic → Revision → Compositor

Each scene writer receives the last 1,500 characters of the prior scene to maintain continuity. The Voice Critic checks tense, POV, pacing, and dialogue quality.

Kind-specific formatting enforced:

Kind	Format Rules
novel	Scene headers, dialogue, interior monologue (italics), sensory anchoring, hooks
memoir	First-person intimate voice, time/place anchoring, reflective passages
book	Authority tone, thesis-driven, smooth evidence integration, reader address, subheadings
screenplay	INT./EXT. headings, action (present tense, ≤3 lines), character cues, sparse parentheticals, transitions (CUT TO / DISSOLVE TO)

---

Web App Pool

Full-stack web applications: Flask backend + Vue 3 frontend + SQLite database, built on a fixed Canon v1 scaffold.

Pipeline — 10 sequential stages:

Spec Generator → Scaffold Copy → DB Architect (slot-fill) → API Implementer (slot-fill)
→ Vue Architect → Vue Implementer (slot-fill) → Integration Check → Integration Fixer (slot-fill)
→ CSS Writer (slot-fill) → README Writer (slot-fill)

Stage	Output
Spec Generator	Emits validated AppSpec JSON (entities, routes, views) for deterministic slot-fills
Scaffold Copy	Copies agents_make/canon/web_app_v1/ (working app shell before feature slots are filled)
DB Architect	Fills schema.sql slots (tables, seeds) from spec + life-admin seed
API Implementer	Fills app.py feature slots only (routes/imports) with envelope helpers + py_compile import-smoke checks
Vue Architect	Component/store plan derived from Flask routes
Vue Implementer	Fills index.html + app.js feature slots (Vue 3.5 prod CDN, Composition API, fetch-based, no axios)
Integration Check	Flags route/fetch mismatches, CORS issues, JSON field name divergence
Integration Fixer	Re-fills only the impacted slots (no full-file rewrites)
CSS Writer	Fills styles.css feature slot using Canon neuromorphic tokens (var(--neu-*))
README Writer	Fills README.md feature slots (feature-list, run-notes)

Automated guardrails in-pipeline:py_compile + import smoke + runtime smoke (/api/health + spec-derived GET probe), Vue binding audit (setup() return vs template refs), feature-coverage check (backend + frontend presence for user-named features), policy lints (route naming, envelope conformance, CSS token usage, strict comment/docstring checks), and plumbing integrity verification against Canon v1 outside slot regions.

Extend Mode — detects existing builds automatically.

• Canon build (.canon-version present): copies prior app and updates only named slots.
• Legacy pre-canon build: one-shot migration into Canon slots, then pins .canon-version for all future extends.

Output structure:

Projects/{slug}/implementation/{timestamp}_app/
├── schema.sql
├── db.py
├── app.py
├── templates/index.html
├── static/app.js
├── static/styles.css
├── README.md
├── BUILD_SUMMARY.md
└── INTEGRATION_NOTES.md (if integration issues were found and fixed)

Model:qwen2.5-coder:7b (or qwen2.5-coder:14b when available, all generation stages)

---

Desktop App Pool

Desktop applications: .NET 8 + Avalonia UI, MVVM, Windows-first with Linux portability.

Stack: Avalonia 11.x UI framework + ReactiveUI ViewModels + SQLite data layer

Pipeline — 7 sequential stages:

Specifier → Architect → ViewModel Impl → View Impl → Services Impl → Build Check → README Writer

Stage	Output
Specifier	App name, features, state model, data layer, UI layout, external dependencies
Architect	Full project scaffold: .sln, .csproj, Program.cs, App.axaml
ViewModel Impl	ReactiveUI ViewModels with [Reactive] properties and ReactiveCommands
View Impl	AXAML Views (data-bound, no code-behind logic) + minimal code-behind files
Services Impl	IService interfaces + implementations (repositories, file I/O, etc.)
Build Check	Project structure validation, dotnet syntax check
README Writer	Windows build steps, Linux port notes, MVVM architecture overview

Output structure:

Projects/{slug}/desktop_apps/{AppName}/
├── README.md
├── .gitignore
├── {AppName}.sln
└── src/{AppName}/
├── {AppName}.csproj
├── App.axaml / App.axaml.cs
├── Program.cs
├── ViewModels/
├── Views/
├── Models/
└── Services/

Models:qwen2.5-coder:14b (architect/implementation stages), qwen3:8b (spec/readme)

---

Talk Lane

Conversational orchestration. Requests that aren't research or build tasks route here — the Reynard layer handles multi-turn dialogue, memory retrieval, and personal context via dolphin3:8b.

Fixed-stack capability injection. Chat prompt assembly includes a static capabilities block for Make coding types:

• tool → Python 3.12+ single-file/CLI stack
• web_app → Flask 3.x + Vue 3.5 (CDN) + SQLite (sqlite3)
• desktop_app → .NET 8 LTS + Avalonia 11 + ReactiveUI

For these types, stack/framework/database choice is treated as system-fixed by default; re-evaluation is routed through a Technical topic.

Two-stage routing gate. Every incoming request is first scored by a semantic-router layer (embedding lookup against known web vs. no-web exemplars, ~20ms) and only falls through to the gemma3:4b intent confirmer for genuinely ambiguous messages. A second qwen3:4b context gate validates the routing decision against full conversation history before any web-research pipeline fires, eliminating false-positive crawls on long technical messages.

---

Turn Orchestration (LangGraph)

Every turn runs through a LangGraph StateGraph defined in SourceCode/orchestrator/pipelines/turn_graph.py:

ingest → prompt_digest → intent_confirm → lane_route → context_gate
→ lane_execute → compose → persist

State is checkpointed at every node boundary into Runtime/state/turn_checkpoints.sqlite via SqliteSaver. Any past turn can be replayed end-to-end or resumed from a specific node via turn_replay.py; a regression harness (regression.py) re-runs a curated set of past turns against current code and flags semantic drift via embedding cosine comparison.

This replaces the legacy monolithic dispatch and makes turn failures debuggable: a crashed node leaves preceding checkpoints intact for inspection and resumable replay.

---

Model Distribution

Task	Model	Context
Orchestration / reasoning	deepseek-r1:8b	12,288
Research & synthesis	qwen3:8b	12,288
Conversation (Reynard)	dolphin3:8b	8,192
Creative writing	qwen3:8b	12,288
Content (unrestricted topics)	huihui_ai/qwen3-abliterated:8b-Q4_K_M	8,192
Specialist / longform	qwen2.5:32b / deepseek-r1:14b (if available)	24,576
Code (web apps)	qwen2.5-coder:7b / :14b	12,288
Desktop app scaffold	qwen2.5-coder:14b	16,384
Intent gate	gemma3:4b	4,096
Routing context gate	qwen3:4b	4,096
Embeddings / RAG / semantic routing	qwen3-embedding:4b	—
Make-type classifier (LT)	SetFit over sentence-transformers	CPU

All models run locally via Ollama or llama.cpp. Model assignments are configurable in SourceCode/configs/model_routing.json.

---

Inference Backends

Foxforge supports two local inference backends:

• Ollama — default backend; handles most models via the Ollama API
• llama.cpp (OpenAI-compatible endpoint) — for TurboQuant and custom quantized models; configured per-model in model_routing.json under llama_cpp_servers

The inference router automatically falls back to Ollama if a configured llama.cpp server is unreachable. Server backoff is 180s after failure.

---

Architecture

 ┌─────────────────────────────────┐
│ Flask Web GUI │
│ auth · REST API · job queue │
└──────────────┬──────────────────┘
│
┌──────────────▼──────────────────┐
│ Two-Stage Routing Gate │
│ semantic-router (~20ms) │
│ → intent confirmer (gemma3:4b) │
│ → context gate (qwen3:4b) │
└──────────────┬──────────────────┘
│
┌──────────────▼──────────────────┐
│ Turn Graph (LangGraph) │
│ 8-node StateGraph · SqliteSaver │
│ checkpointing · replay │
└───┬─────────┬──────────┬────────┘
│ │ │
┌──────────────▼┐ ┌─────▼──────┐ ┌▼──────────────┐
│ Research Lane │ │ Make Lane │ │ Talk Lane │
│ │ │ │ │ │
│ Tree planner │ │ essay │ │ Reynard layer │
│ 4 personas + │ │ longform │ │ dolphin3:8b │
│ handoffs │ │ content │ │ │
│ │ │ specialist │ │ │
│ Synthesizer │ │ creative │ │ │
│ Citation linker│ │ web app │ └───────────────┘
└────────────────┘ │ desktop │
└─────┬──────┘
│
┌──────────────▼──────────────────┐
│ Memory Systems │
│ Typed: episodic · semantic · │
│ procedural. Paged working set + │
│ archival. Web-research cache. │
└──────────────┬──────────────────┘
│
┌──────────────▼──────────────────┐
│ Local Inference │
│ Ollama · llama.cpp │
│ health-check + adaptive │
│ model fallback │
└──────────────┬──────────────────┘
│
┌──────────────▼──────────────────┐
│ Optional External Services │
│ SearXNG · Crawl4AI · ComfyUI │
│ MCP server / client (stdio) │
└─────────────────────────────────┘

---

Feature Status

Feature	Status	Notes
Research lane (deep researcher + synthesizer)	Available	4-persona parallel research with evidence discipline
Essay pool	Available	6-stage pipeline, 10+ topic templates
Longform pool	Available	7 output types with word-count enforcement
Content pool	Available	Blog, social, email with feedback learning
Specialist pool	Available	Medical, finance, history, sports, game design
Creative pool	Available	Novel, memoir, book, screenplay with continuity
Web app pool	Available	Flask 3.x + Vue 3.5 (prod CDN) + SQLite (sqlite3), Canon v1 scaffold + slot-fill Extend Mode
Desktop app pool	Available	.NET 8 + Avalonia, MVVM scaffold
Topic system + Second Brain memory	Available	Persistent context across sessions
Typed memory (episodic / semantic / procedural)	Available	Conflict resolution via source reputation + recency
Memory pager (working set + archival)	Available	Token-budgeted context; [RECALL:] directive for self-paging
Intent confirmer	Available	Fast gate prevents accidental pool activation
Semantic routing gate	Available	Embedding-based ~20ms front-of-gate; LLM tiebreaker on low score
Chat routing context gate	Available	qwen3:4b validates keyword triggers against full conversation
Turn state graph (LangGraph)	Available	8-node StateGraph with SqliteSaver checkpointing
Turn replay + regression harness	Available	Resume any past turn from any node; drift scoring via embedding cosine
Web research cache	Available	Content-addressed SQLite, volatility-tiered TTL
Ollama health-check + adaptive fallback	Available	Model degradation demotes primary; auto-recovers after decay
Research tree planner	Available	Planner → executor; per-persona leaf affinity
Research persona handoffs	Available	LLM self-reflection with loop prevention + cap
Per-sentence citation linker	Available	Cosine-aligned source anchoring; weak citations dropped
SetFit Make-type classifier	Available	CPU inference replaces LLM suggested_type pick; active learning loop
MCP tool surface (server + client)	Available	Exposes forage / recall / make over stdio; consumes external MCP servers
Feedback learning engine	Available	Learns from successful Make outputs
Watchtower / briefing flows	Experimental	Active and evolving
Bot integrations (Discord / Slack / Telegram)	Experimental	Optional, environment-dependent
Local image generation (ComfyUI)	Experimental	Optional external service, model-dependent
Image-to-video (Wan2.2 / SVD XT)	Experimental	Optional, VRAM-dependent

---

Platform Support

Platform	Status	Notes
Ubuntu 24.04 LTS	Tested (primary)	Preferred for GPU inference
Ubuntu 22.04 LTS	Tested	Installer supports this target
Windows 11	Tested	Installer + web launcher supported
Other Linux distros	Experimental	May work, not in tested matrix
macOS	Untested	No official support commitment

---

Requirements

• Python 3.10+
• Ollama running locally (required)
• Docker (optional — for web-foraging stack: SearXNG + Crawl4AI)
• ComfyUI (optional — for local image generation and image-to-video)
• Core Python deps (via requirements.lock): LangGraph + SqliteSaver for turn orchestration, semantic-router for fast routing, SetFit + sentence-transformers for Make-type classification, MCP SDK for tool surface
• Optional extras
  • requirements-optional-docs.txt — PDF / DOCX / OCR helpers
  • requirements-optional-bots.txt — Discord bot support
• GPU drivers (optional but strongly recommended)
  • AMD: ROCm 6.x — RX 5000 series and newer
  • NVIDIA: CUDA toolkit — GTX 10xx and newer, any RTX series

---

Optional Web-Foraging Stack

Powers the Research lane's live web foraging. Requires Docker.

Linux:

docker start searxng crawl4ai

Windows:

powershell -ExecutionPolicy Bypass -File .\start_web_foraging_stack.ps1

Default service ports:

Service	Port
SearXNG	8080
Crawl4AI	11235

---

MCP (Model Context Protocol)

Foxforge exposes its research and memory surface as an MCP server — external tools (editors, assistants, other local agents) can call forage, recall, and make_artifact over stdio without touching the web GUI.

python -m orchestrator.mcp

Stdio is the default transport. HTTP is gated behind an explicit config flag and is localhost-only by default; enable with care if you're exposing over Tailscale.

Foxforge also consumes external MCP servers (filesystem, fetch) via SourceCode/shared_tools/mcp_client.py — configured in SourceCode/configs/mcp_servers.json.

---

Local Image and Video Generation

Foxforge connects to ComfyUI for image generation, enhancement, and image-to-video. This is optional and can run on a separate machine.

Supported configurations:

• Pony XL style presets (~8 GB VRAM)
• Classic SD presets (lower VRAM)
• Wan2.2 image-to-video (8+ GB VRAM, recommended 16+ GB)
• SVD XT fallback (4–6 GB VRAM)

For full setup details — required custom nodes, model files, workflow export, Wan2.2 activation, and fallback paths — see ComfyUI image + video setup.

---

Security Notes

• Foxforge is local-only. No data is ever transmitted to an external AI provider.
• Startup scripts can bind to all interfaces (0.0.0.0) for LAN/Tailscale access.
• Use loopback (127.0.0.1) to restrict to local access only.
• Configure host/port via FOXFORGE_WEB_HOST and FOXFORGE_WEB_PORT.
• Set FOXFORGE_WEB_PASSWORD when exposing beyond localhost.

---

Repository Layout

Path	Purpose
SourceCode/orchestrator/	Orchestrator, intent routing, turn planner, Make catalog
SourceCode/orchestrator/pipelines/	LangGraph turn state machine, replay, regression harness
SourceCode/orchestrator/services/	Intent confirmer, semantic gate, chat routing gate, Make-type classifier, MCP bridge
SourceCode/agents_make/	All Make lane pools (essay, longform, content, specialist, creative, web app, desktop)
SourceCode/agents_research/	Tree planner, deep researcher, synthesizer, citation linker
SourceCode/web_gui/	Flask app, API routes, frontend templates and static assets
SourceCode/shared_tools/	Inference router, memory systems, research tools, activity bus
SourceCode/bots/	Discord, Slack, and Telegram bot adapters
SourceCode/configs/model_routing.json	Model assignments, inference servers, fallback config
tests/	Test suite
docs/	Architecture notes, changelogs, planning artifacts
tools/	Utility scripts: health checks, developer tooling
Runtime/	Local runtime state (generated at runtime; user-owned)
Projects/	Generated outputs and artifacts

---

Configuration

Primary model and routing config:

• SourceCode/configs/model_routing.json — model assignments per lane, llama.cpp server entries, context sizes

Useful startup scripts:

• start_foxforge_web.sh (Linux, host/port flags)
• start_foxforge_web.ps1 (Windows)

---

Development Workflow

Provision a dev environment:

python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.lock

Run the standard check suite:

make check

Run checks individually:

python3 smoke_test.py
python3 run_integration_tests.py
python3 tools/ui_phase_smoke.py
python3 tools/repo_health_check.py

Optional feature installs:

pip install -r requirements-optional-docs.txt
pip install -r requirements-optional-bots.txt

---

Packaging and Distribution

Create a clean distributable ZIP:

powershell -ExecutionPolicy Bypass -File .\create_clean_zip.ps1

GitHub-friendly ZIP (include docs/images, exclude installer EXE):

powershell -ExecutionPolicy Bypass -File .\create_clean_zip.ps1 -IncludeDocsAndImages -IncludeInstallerExe:$false

Build installer EXE:

powershell -ExecutionPolicy Bypass -File .\build_installer_exe.ps1

---

Troubleshooting

Ollama not responding

Linux:

sudo systemctl restart ollama
sudo journalctl -u ollama -n 50

Windows:

ollama serve

Foxforge not starting

Linux:

sudo journalctl -u foxforge -n 50

Windows: re-run the start script and check terminal output.

GPU not used by Ollama

AMD (Linux):

rocm-smi
groups $USER# If render/video groups missing:
sudo usermod -aG render,video $USER# Log out and back in

NVIDIA (Linux):

nvidia-smi
# If not found, reboot and check again

Port conflict on web startup

Linux:

sudo systemctl edit foxforge
# Add: Environment="FOXFORGE_WEB_PORT=5051"
sudo systemctl restart foxforge

Windows:

powershell -ExecutionPolicy Bypass -File .\start_foxforge_web.ps1 -WebPort 5051

---

Changelog and Release Notes

• docs/changelogs/phase19_accuracy_semantic_ui.md
• docs/changelogs/phase18c_confidence_and_memory.md
• docs/changelogs/phase18b_research_speed.md
• docs/changelogs/phase18a_query_routing.md
• docs/release_notes_phase18_optimization.md
• docs/release_notes_phase17_research_quality.md

---

Docs Index

• INSTALL_GUIDE.md — recipient-focused install guide
• CONTRIBUTING.md — contribution workflow and standards
• ComfyUI image + video setup — model, workflow, and VRAM guidance
• Workspace tools — utility scripts and tooling notes
• Phase changelogs — milestone-level updates

---

Project Status

Foxforge is functional and actively used. It is in an experimental phase — APIs and config formats may change between releases.

• CI runs on Python 3.10 and 3.12 on every push/PR
• Tested on Ubuntu 24.04 LTS (primary), Ubuntu 22.04 LTS, and Windows 11
• GPU acceleration via AMD ROCm or NVIDIA CUDA; CPU-only also works

---

Contributing

Contributions are welcome. See CONTRIBUTING.md.

---

License

Foxforge is released under the Guideboard Service-Only License 1.0.

• Commercial services around the software are allowed (consulting, integration, support).
• Selling the software product itself is not allowed.
• This is source-available, not an OSI open source license.

Dependency license notes are in THIRD_PARTY_NOTICES.md.