Your intelligence. Your data. Your hardware. Your rules.
Private development. ForgeWire is not available to download or install. This repository is the public project overview; it does not contain the application source, a supported setup path, or a release date.
ForgeWire is a modular environment being built to coordinate models, personas, tools, skills, memory, task execution, and compute around real work. The project starts from a systems-first premise: useful AI depends on the boundaries, state, recovery paths, and human decisions around a model—not only on the model itself.
Start here: What ForgeWire is · Application preview · How the system fits together · What a user can do · Current status · Follow release updates
| If you want to… | Here’s the current path |
|---|---|
| Try ForgeWire | There is no public build, installer, or supported installation path yet. |
| Understand the product | Read the system overview and diagrams below. Each diagram labels current composition separately from work in progress. |
| See the interface | View a genuine Projects workspace capture below. Other product views are listed with their capture status; setup screens remain secondary. |
| Follow a future release | Use Watch → Custom → Releases on this repository, or visit Releases. No date has been announced. |
| Explore related public work | Visit ForgeWire Labs, SCOUT-2, RepoPact Core, or ForgeLink. Their availability and terms are described in their own repositories. |
Reading the diagrams: they describe verified code paths and architecture direction, not a feature checklist. Captions call out where composition is current, configuration-dependent, private, or still being reconciled. A picture does not mean every box is a public or end-to-end feature.
Most assistants are organized around a model and a conversation window. ForgeWire is being organized around the work: understanding a request, selecting relevant capabilities, preserving useful context, coordinating bounded steps, and returning an outcome a person can review.
The aim is not to make one model pretend to do everything or to replace human judgment. The aim is to coordinate different models, software, data, and compute within visible responsibilities—and to make the system useful when a provider, dependency, or machine is constrained.
ForgeWire is an application and runtime for coordinating intelligent work. It is not a single chatbot, an autonomous agent with blanket authority, or a public model-hosting service. Its capabilities are divided among components with different jobs:
| Part | Responsibility | Maturity in the current private application |
|---|---|---|
| Personas | Give an interaction a named identity and a policy reference; available persona definitions shape behavior and capability access. | Persona definitions are loaded by the application. The persona contract is a system boundary; catalog management and surrounding UX remain product features. |
| Providers and models | Supply language-model responses and tool-call proposals. | The private application resolves a configured provider/model. Which local or hosted providers work depends on integration and workspace configuration. |
| Tools | Perform bounded operations such as reading information or calling an integration. | Tools are reached through shared tooling services. Availability and permissions depend on the installed workspace and configuration. |
| Skills | Describe or compose capabilities into reusable workflows. | Skill metadata and tooling exist. Dynamic skill resolution is proposed; a shared vocabulary for capability requirements and routing is active design work. |
| Agents | Carry out delegated work with an explicit scope and return a result. | Selected workflows use existing agent and graph paths. One consistent run lifecycle across chat, tools, and delegated work remains architecture work. |
| Services and stores | Manage conversations, knowledge, memory, tasks, jobs, and other application state. | Multiple service and repository paths exist. A given path can be unavailable when its optional service or backend is not configured. |
| Projects | Group related chats with shared instructions and files without replacing the active persona. | The private GTK workspace supports project creation, files, chat association, and archive/restore. Project content remains account-scoped. |
| Execution substrates | Run bounded work in a portable runtime and, in a separate project direction, across authorized machines. | Graph execution is used in some private workflows. Unifying end-to-end run ownership and the runtime migration remain active work; Fabric integration and distribution are not public deployment options. |
Personas are more than renamed prompts: their operating profile includes identity, behavioral boundaries, and references to policy and capability access. The persona identity and policy-reference contract belongs to the system boundary, while catalogs, management interfaces, and other persona features remain product surfaces.
Model and provider choices should remain replaceable. Local, hosted, and specialist models can serve different needs when an installed workspace supports and configures them; provider availability is not uniform across workspaces.
Agentic systems are systems first and models second.
Survivability under deployment—graceful degradation, layered ownership, parity paths, audit trails, and replaceable substrates—is the property that determines whether a system is useful, not benchmark scores on a model card.
Models can be useful and still be wrong, slow, unavailable, or replaced. ForgeWire treats them as one part of a larger system that must make state and ownership visible, preserve human control, and expose the limits of its current recovery paths. This thesis is an engineering direction; it is not a claim that every listed property is complete today.
Projects workspace in a private GTK development build, captured in August 2026 with disposable sample data. This is the real workspace widget rendered with the application stylesheet and service-backed sample state; it is not a full-window capture of the current signed-in shell. A project groups chats, files, and instructions while the active persona remains authoritative.
The signed-in tour remains in progress. Genuine captures from 2026-10-11 cover the corrected disabled Tasks and Jobs pages, Calendar and Budget views, several Operations surfaces, History, Settings, and Builder catalogs. After the latest reopen, Tasks and Jobs still report scheduling disabled; Background Automation shows Job Scheduling as not running with its switch off. The latest Skills capture shows an empty Available Skills list and “No skill selected”; it does not show the initialization-error dialog captured after the previous reopen. Skill loading and metadata availability remain unverified. The Knowledge Library is empty (0 items) with RAG off; the separate RAG Settings page and blank New Collection dialog remain captured, and Docs has a text-preview fallback. The current Chat shell is blank, with a visible empty composer and “No project”; no prompt was sent and Chat response behavior remains unverified. A current conversation timestamp appeared in the History sidebar; the conversation was not opened or captured. The Projects page remains unavailable pending operator sign-in and project-store initialization, and its blank form was not submitted. The Account page is accessible, but no account was selected and no account details were opened. The inventory below lists remaining route and dialog gaps.
| View | Verified capture |
|---|---|
| Work: Tasks and Jobs | Latest post-reopen captures: Tasks disabled; Jobs disabled. Both say scheduling is explicitly disabled; the scheduling setting was not changed and no jobs were run. Earlier captures remain linked: Tasks; Jobs. Historical initialization errors remain labeled below. |
| Work: Calendar and Budget | Calendar Month; Budget Dashboard, redacted. Full view inventory follows below. |
| Builder | Personas; Providers; Tools; latest Skills empty list, captured directly through the Windows Desktop MCP. The earlier Skills empty-list capture and initialization-error dialog are preserved. The latest view does not verify that skill metadata loads. |
| Knowledge | Latest post-reopen Library capture shows 0 items with RAG off. The blank New Collection dialog was not submitted. RAG Settings remains unchanged, with the main RAG switch off. Earlier Library and Docs text-preview fallback captures remain preserved. Memory navigation is role-gated and absent for this account; it was not bypassed. |
| Operations | Orchestration; Status; Agent Activity, 0 active agents; Handoffs; Intervention form; Health after restart; BenchLab, worker details and log paths redacted; Guardrails; MCP Servers, 0 configured; Vector Store. |
| History | Latest Projects page after reopen says Projects are unavailable until operator sign-in and project-store initialization; project fields are blank and the form was not submitted. The earlier All Chats empty capture predates this login. A current conversation timestamp appeared in the sidebar after reopening, so All Chats was not opened and no conversation content was captured. Archived Projects did not open a separate page; its contents remain unverified. |
| Settings and Notifications | Settings navigation; Knowledge Base & RAG Settings, with RAG off and no settings changed; Notifications empty, sidebar metadata redacted; API Keys, redacted; latest Background Automation shows Job Scheduling as not running and its switch off. No settings were changed. |
| Conversation and response review | Latest empty Chat shell shows a blank composer and “No project”, with no conversation content. No prompt was submitted, so response behavior is not established. The older pre-conversation capture remains labeled in the historical section. |
| Global search and application menus | Empty global-search palette; File, Edit, View, and Help menus after restart. Older Knowledge and menu captures remain preserved below. |
| Fabric operator and runner surfaces | Private development; not shown. |
These genuine captures show the corrected deferred-model path in a separate process using temporary configuration and data roots. The recommended local model remains uninstalled, and the guidance says it can be acquired after setup. No account was registered and no credential was entered. The Finish action was not invoked. The optional Cloud AI page showed masked configured-provider states, so it was not retained as a capture.
| Step | Verified capture |
|---|---|
| Preflight | Model installation can be deferred — the recommended model is not installed, and setup can continue with the listed limitations. |
| Providers / Local AI | Local model remains uninstalled — the wizard says setup can finish first and Chat stays unavailable until a local model or cloud Chat provider is configured. |
The two captures verify the corrected guidance in the current source build. Finish completion without a model or token is verified by focused tests; this isolated run intentionally stopped before account creation.
Secondary preview: genuine setup screens from an internal build
These three images are actual setup screens from an internal development build. They show setup concepts, not a finished product tour or a public installer.
Welcome |
Storage options |
Local workspace |
|
Historical setup and partial signed-in captures (29 images)
These genuine GTK captures were taken on 2026-10-10 from the 0.1.0 setup build and the older signed-in process. The setup run used a disposable profile and demo workspace; it did not register the synthetic administrator. Cloud credential fields were blank. The signed-in images are historical and predate the setup and Tasks/Jobs fixes; they do not establish current behavior. New signed-in captures are cropped to the application window and have the personal status text masked. The Chat shell was captured before the current conversation began. The Tools detail pane is masked, and the menus retain only the relevant menu area.
The sequence shows the earlier setup validation mismatch: Preflight described model acquisition after setup, while Finish required an installed model or Hugging Face token. No model or token was used. The wizard now supports deferred installation; Chat stays unavailable until a local model is installed or a cloud Chat provider is configured. An uninstalled recommendation is not saved as an active Chat default. A Hugging Face token is only needed for gated or private model sources.
The following screens were captured from the already signed-in process. The Chat shell was empty before the current conversation began. The Library was empty. The Documentation Browser displayed its text-preview fallback because WebKit was unavailable. The Providers page showed provider names only. The Skills page raised an initialization error. These captures document the observed UI and must not be read as proof that those functions are currently working.
These screens show initialization errors and the blank Work content area before the disabled-state fix. They are evidence of the earlier state, not the current Tasks or Jobs result.
| Surface | Screens and relevant dialogs | Verified coverage |
|---|---|---|
| First-run setup | Introduction, Preflight, Users/Admin, Storage/Advanced Storage, local workspace and native folder picker, Local AI, Cloud AI, Defaults | All 12 historical first-run captures remain preserved. Current isolated Preflight and Local AI pages show deferred installation. Focused tests verify Finish validation without a model or token. Finish was not invoked; no account or model was created. |
| Signed-in Chat | Main Chat, Blackboard, Context, Debug, conversation view | Latest Chat shell is blank, with an empty composer and no project. No prompt was sent. The current History conversation was not opened or captured. Chat response behavior remains unverified. |
| Work: Tasks and Jobs | Current task/job pages; earlier initialization dialogs | Latest Tasks and Jobs captures show the deliberate disabled state. Earlier error captures remain historical. Scheduling stayed disabled; no real jobs were run. |
| Work: Calendar | Month, Week, Day, Agenda, Sources, Categories, Settings, Sync | All eight listed pages captured on 2026-10-11. |
| Work: Budget | Dashboard, Policies, History, Reports, Alerts, Channels | All six listed pages captured on 2026-10-11. Financial totals and history entries were redacted where visible. |
| Knowledge | Library, Docs, Memory, RAG | Latest post-reopen Library reports 0 items with RAG off; the New Collection dialog has blank fields and was not submitted. The separate RAG Settings page remains unchanged, with the main RAG switch off, automatic retrieval on, and a 4,000-token context limit. Current Docs uses the text-preview fallback because WebKit is unavailable. Memory navigation is role-gated and absent for this account. Earlier captures remain preserved. |
| Builder | Personas, Background personas, Providers, Tools, Skills | Latest Skills view captured through the Windows Desktop MCP shows an empty list and no selected skill; metadata loading is unverified. Earlier captures, including the initialization-error dialog, are preserved. Provider credentials were not opened. |
| Operations | Orchestration (Status, Agent Activity, Handoffs, Intervention), Observability (Health, BenchLab), Guardrails, MCP (Servers only; 0 configured), Vector Store | Current captures cover the listed views, including the refreshed Health and BenchLab pages and the latest-session Agent Activity. The blank Add BenchLab host form is captured; no form was submitted. Worker diagnostics and log paths are redacted. Metrics, Traces, Alerts, Approvals, Audit Log, MCP Tools, and MCP Status were not surfaced in the current Operations navigation and remain uncovered. |
| History | All Chats, Projects, project creation, archived projects | Earlier All Chats showed an empty list before the latest login. A current conversation timestamp appeared in the History sidebar after reopening; All Chats was not opened, to avoid capturing it. Latest Projects says Projects are unavailable until operator sign-in and project storage initialization; blank project fields were not submitted. The current session did not open Archived Projects, so archived contents remain unverified. |
| Settings | API Keys, Search & Weather, Image Generation, Communication Channels, Message Bus, Calendar Sources, Speech providers, Background Automation, Keyboard Shortcuts, Backups, Factory Reset | Existing captures cover the listed pages. The latest Background Automation capture shows Job Scheduling not running and its switch off. Credentials and conversation metadata are masked. Backup/restore and factory-reset actions were not run; the factory-reset page is a safe inspection only. |
| Other navigation | Account, global search, notifications | The empty global-search palette and Notifications are captured. The latest Saved Accounts page loaded one account, but no account was selected and the identifying detail fields remained blank. Account editing remains uninspected. |
| Menus | File, Edit, View, Help | Current captures from 2026-10-11 are linked above; older captures remain preserved. |
| Dialogs | Setup picker and setup pages; historical Skills initialization error; MCP add-server and Operations intervention forms; blank BenchLab Add host form; blank New Collection dialog; empty global-search palette; Factory Reset inspection; historical Tasks/Jobs errors | Forms were not submitted and destructive actions were not confirmed. Account/project editing, library file actions, provider verification, calendar authorization, and approval/review dialogs remain uncovered. |
The diagrams use a small visual key:
- Blue marks an existing implementation path. Availability may still depend on workspace configuration.
- Purple marks an optional or configuration-dependent path.
- Green marks private implementation, including Fabric's alpha control plane.
- Amber and dashed mark proposed or in-progress behavior that is not yet a complete product path.
- Each diagram has an editable Mermaid source beside its rendered SVG export.
The view separates the GTK user path and internal HTTP routes from application composition, core services, orchestration, provider and tooling integrations, persistence, and messaging. The ForgeWire Runtime Core is a conceptual boundary spanning packages; it is not the forgewire_core/ package. Forge Core messaging and the Python graph execution path are distinct substrate roles. Fabric is a separate private execution control plane reached through limited, configured paths; it does not own the application's semantic state.
Source: system-boundaries.mmd · SVG export.
Boundary note: GTK is the current desktop path; HTTP routes are an internal integration surface. Interface and service boundaries remain under reconciliation, so the diagram does not promise equivalent behavior across surfaces. A limited Fabric integration exists for selected, configured workflows; it is not a public remote service.
ForgeWire keeps identity, model choice, available capabilities, and delegated execution conceptually distinct. A persona carries identity and a policy reference; provider/model selection is workspace-configured; tools perform bounded operations through capability boundaries. Skill metadata exists, while dynamic skill resolution is proposed and shared capability/routing contracts are active design work. Agent and multi-agent paths are used by selected workflows; a consistent run lifecycle across chat, tools, and delegated work remains architecture work.
Source: capability-composition.mmd · SVG export.
User-facing instruction: in a private workspace, select an available persona before starting a conversation. The active persona and provider choices are controlled by that workspace. Review a response and any proposed action; a model response alone is not authorization to perform a consequential action.
ForgeWire Fabric is a related, private execution control plane for authenticated, policy-gated work across machines. A limited, configuration-dependent integration exists for selected application workflows. The diagram separates the application's dispatch and semantic ownership from Fabric's remote placement and execution role. It shows the conceptual authority check, bounded work, returned status, and operator review without publishing private protocol, enrollment, endpoint, credential, or deployment details.
Source: fabric-dispatch.mmd · SVG export.
Status: Fabric's current and future development is private and proprietary unless a specific distribution is explicitly licensed otherwise. Broader application integration, conformance, and release gates remain open. The flow is an architecture view, not a public service. The application owns the original dispatch decision; returned remote status is reviewed in the application, and the operator decides follow-up.
Conversation history, short-term request context, optional memory services, knowledge retrieval, tasks, jobs, shared workflow state, and operational events have different purposes. The application has separate services and persistence paths; provider access, retention, knowledge indexing, and retrieval depend on workspace configuration. The diagram does not imply that every memory is persisted or supplied to every request.
Source: context-and-state.mmd · SVG export.
The application uses an in-process asynchronous message bus, while synchronous local notifications follow a separate path. Task/job records are operational state, not conversation memory. Distributed execution belongs to the separate Fabric direction; these mechanisms do not create a public durability, replication, or cross-shell event guarantee.
The current user guide supports reviewing tasks produced by configured workflows. The task panel does not itself provide a general task-creation action. Selected graph and task paths include bounded retries, and the ManualInterventionPanel supports explicit operator review. Run-wide checkpoint/resume, idempotent replay, and automatic escalation are not established as universal product behavior.
Source: task-recovery.mmd · SVG export.
Current private-workspace path: open the task area, select a task, and review its description, status, and available actions. Ask the workspace operator which workflow creates tasks. The task UI does not provide general task creation, and its review controls do not imply an automated recovery path.
These instructions apply only to a workspace that has already been installed and configured by its operator. They are not a public installation guide.
- Open ForgeWire. Use the application launcher configured for your workspace.
- Sign in if required. Use the workspace account. Contact its operator if you do not have one or sign-in is unavailable.
- Choose an active persona. Open the Personas manager, choose an available persona, and confirm it is active. The current conversation uses that persona.
- Start a conversation. Open the conversation workspace, send a short request, and review the response before acting on recommendations.
- Organize related chats in a project. Under History → Projects, create a workspace for shared instructions and files. Project context supplements the active persona; it does not replace persona policy or capability grants.
- Use knowledge features when configured. If retrieval is enabled, the workspace may allow document upload and knowledge-base queries. Check indexing and use the query test view to verify what was retrieved.
- Review tasks. Open the task area and select a task created by a configured workflow. Review its description, status, and available actions. The UI does not currently provide general task creation.
Provider credentials, account access, storage, and optional knowledge services are operator-managed. If a provider request fails, ask the operator to confirm the persona has access to an available provider. These steps describe the current private application path and may change before a public release.
The first-run wizard can finish without an installed local model or cloud credentials. Chat remains unavailable until a local model is installed or a cloud Chat provider is configured. The wizard requires a Hugging Face token only for gated or private model sources.
- Operators who need to understand where work runs, how it is configured, and where their decisions belong.
- Builders connecting providers, tools, application services, and user-facing workflows.
- Researchers studying reliability, bounded reasoning, state, evaluation, and failure behavior in agentic systems.
- Teams exploring reviewable work and durable state beyond a conversation transcript.
ForgeWire is not currently a hosted service, supported enterprise deployment, or open-source application framework. Its complete source is not published in this overview repository.
ForgeWire is developed around the assumption that providers, dependencies, hardware, and remote connections can fail. The system should make that state inspectable and keep action authority explicit.
The engineering goals include:
- graceful degradation when optional components are unavailable
- clear service ownership and replaceable model or infrastructure choices
- parity evidence when alternative implementations are introduced
- traceable actions and outcomes
- scoped capabilities and human approval for consequential actions where policy requires it
- visible failure and a safe way to stop or escalate
Those are design requirements, not blanket assurances about current product coverage. The architecture and deployment boundaries continue to evolve. A future release should describe the controls present in that build and publish validation evidence for them.
ForgeWire provides a product path for selected research from ForgeWire Labs. Current areas of interest include bounded recurrent reasoning, task-local cognitive control, continual learning, adaptive routing, calibrated fusion, specialist models, hybrid language and state models, evaluation and replay, persistent agency, and temporal continuity.
Research is not automatically product capability. Experimental work should move through isolation, baseline comparison, controlled evaluation, failure analysis, observe-only integration, and limited canary use before production adoption is considered.
SCOUT → SCOUT-2 → ATLAS → PhrenForge → ForgeWire
The project evolved from a multi-agent assistant toward a broader application with personas, tools, services, structured messaging, execution boundaries, and repository-native governance. That history records repeated implementation and redesign; it does not mean every capability from an earlier generation exists in the current product.
- ForgeWire Fabric — private distributed execution and control-plane development associated with ForgeWire. Current and future development is proprietary unless a specific distribution says otherwise. Historical copies previously distributed under Apache License 2.0 remain governed by the terms that accompanied those copies; their granted rights are not revoked here.
- SCOUT-2 — an earlier multi-agent assistant and part of the public project lineage.
- ForgeWire Labs — independent engineering and applied AI research.
- RepoPact Core and ForgeLink — separately maintained public projects. Consult their repositories for their own status and terms.
| Area | Status |
|---|---|
| Public overview | Available in this repository |
| Complete ForgeWire application source | Private development; not published here |
| Public download or installer | Not available |
| Supported public installation path | Not available |
| Stable public API or compatibility promise | Not announced |
| Public release date | Not announced |
| ForgeWire Fabric source and deployment | Private development; not available from this repository |
Private development is proprietary unless a specific distribution is explicitly licensed otherwise. Historical releases or copies that ForgeWire Labs previously distributed under Apache License 2.0 remain under the license terms that accompanied those specific copies. This overview does not change those terms or license current private development.
A public release should include supported-platform and installation guidance, security and data-handling details, known limitations, migration and recovery guidance, and validation evidence for the released build. There is no waitlist or announced release date.
- Select Watch near the top of this repository.
- Choose Custom, then enable Releases to receive release notifications. See GitHub's notification guide for the current steps.
- Star this repository if you want to keep it in your GitHub bookmarks.
- Check the Releases page and this README for current status. A release will be announced here when one is ready.
ForgeWire is designed and developed by Jeremy Shows through ForgeWire Labs. He defines the problems, designs the architecture, establishes engineering constraints, and drives implementation, integration, debugging, and validation. His approach draws on a lifelong background in fabrication, mechanical systems, IT, and software development, with an emphasis on making complex systems work under real constraints.
AI models and coding agents contribute across research, architecture exploration, implementation, debugging, testing, review, and documentation. Jeremy directs that work, challenges assumptions, resolves conflicting recommendations, and evaluates results through code review, tests, experiments, and observed system behavior. The architecture, technical judgment, and responsibility for what ships remain his.
Work across ForgeWire and adjacent components has included Rust, Python, TypeScript, GTK, React, PostgreSQL, SQLite, and rqlite, alongside structured messaging and local or hosted model-provider integrations. This is a high-level inventory across a broader private effort—not a compatibility list, deployment guide, or promise that each technology is currently composed in the application. These are replaceable choices, not the identity of the system.
Most assistants optimize for conversation. ForgeWire is being built to make AI-assisted work more inspectable, bounded, recoverable, and useful under real constraints.