Build desktop agents from a single piece of code.
Kynetra Forge turns one codebase into a native, intelligent desktop app on macOS, Windows, and Linux. The planner, MCP tools, memory, and a sandboxed plugin host aren't add-ons — they're the runtime. And the whole dev → build → update → ship lifecycle is one forge command away.
- 3
- platforms, one source
- 8
- forge commands, full lifecycle
- 0
- reinstalls — OTA updates
use forge_sdk::app;
fn main() -> anyhow::Result<()> {
app("my-agent")
.enable_rpc() // local kernel + agent runtime
.window(|w| w
.url("dist")
.size(1200, 800)
.title("My Desktop Agent"))
.run() // macOS · Windows · Linux
}the whole app — window, kernel, and agent loop
Write it once. Forge ships it everywhere — natively.
No Electron-sized Chromium per app, no separate native shells to maintain. Forge drives each OS's own webview from a single Rust source tree, so your agent is one small native binary on every target.
src/
├─ main.rs → app("my-agent")
├─ tools.rs → MCP capabilities
└─ ui/ → your consoleOne project. One language. One mental model.
Everything an agent needs to think, act, and ship.
Most desktop frameworks hand you a window and leave the intelligence to you. Forge makes the agent loop a first-class citizen of the runtime.
A real planner-executor loop
Give the agent a goal. It synthesizes a plan as a typed DAG, then the executor runs steps concurrently with dependency ordering and retry budgets — not a single prompt-and-pray call.
MCP tools as the agent's hands
echo, clock, http.get, fs.read, fs.list ship built in. Register your own tools and they appear to the planner automatically. Errors come back as usable strings, never silent failures.
Memory that persists
Every goal and run is recorded as an episode. Recall is semantic when an embedding backend is configured, with an explicit, never-silent fallback when it isn't.
Sandboxed plugin host
Extend the runtime with WebAssembly Component Model plugins. Host functions for MCP invocation, inference, and memory are injected through typed seams — capabilities, not ambient access.
Native windows, no Chromium tax
Each platform's own webview (WKWebView, WebView2, WebKitGTK) via wry + tao. Small binaries, fast cold start, real OS integration — bring any web UI or use the built-in Studio console.
Local-first RPC kernel
A JSON-RPC server on 127.0.0.1 with SSE streaming drives inference, memory, tools, and the agent. Your UI — or any local process — talks to the runtime over a stable contract.
Provenance & capabilities built in
Trust, audit, and a capability protocol are part of the runtime's moat — agents act under explicit grants, and what they did is inspectable after the fact.
Rust all the way down
One typed, memory-safe codebase from window to planner. No Node runtime on the target, no FFI maze — clippy-clean, formatted, and tested across the workspace.
Not just a runtime — a desktop app platform.
Expo gave mobile teams dev, build, OTA updates, and CI from one toolchain. Forge brings that whole loop to desktop agents — every stage is one forge command backed by a real Rust crate.
Dev server
Instant UI preview with live reload and a dev manifest a Forge Go host can load. No native recompile for UI changes.
Build matrix
Multi-target profiles across macOS, Windows, and Linux — every run produces a hashed artifact manifest.
OTA updates
Signed, channel-based over-the-air updates with staged rollout percentage and one-command rollback.
Distribute
Push installers to GitHub Releases, Cloudflare, or a filesystem channel in a single command.
Workflows
Declarative CI/CD that runs locally and generates GitHub Actions. One pipeline definition, two runtimes.
Hosting
Ship the web surface and API routes to Cloudflare. Your agent's web layer, deployed from the same CLI.
Prebuild
Generate the native shell from forge.toml with config plugins — CNG for desktop. No hand-written native glue.
Metadata
Validate and emit store-listing metadata. Keep your distribution metadata in code, not a dashboard.
Define, run, extend, ship — without leaving the source tree.
use forge_sdk::app;
fn main() -> anyhow::Result<()> {
// One codebase. A real native window (WKWebView / WebView2 / WebKitGTK),
// a local JSON-RPC kernel on 127.0.0.1:7710, and the agent runtime.
app("my-agent")
.enable_rpc()
.window(|w| {
w.url("dist") // your UI, or the built-in Studio console
.size(1200, 800)
.title("My Desktop Agent")
})
.run() // → macOS, Windows, and Linux from the same source
}One entrypoint. A native window, a local RPC kernel, and the agent runtime — wired in a handful of lines.
A window framework gets you a shell. Forge gets you an agent.
Tauri and Electron solve the desktop-shell problem well. Neither was built to be the brain. Forge starts from the agent and works outward.
| Capability | Kynetra Forge | Tauri | Electron |
|---|---|---|---|
| Single codebase → macOS / Win / Linux | |||
| Native OS webview (no bundled Chromium) | |||
| Agent planner + executor in the runtime | |||
| MCP tool registry built in | |||
| Persistent agent memory | |||
| Sandboxed WASM plugin host | |||
| Local RPC kernel with streaming | |||
| Capability / provenance protocol | |||
| No Node runtime on target | |||
| Signed OTA updates built in | |||
| Build · distribute · CI · hosting in one CLI | |||
| File-based UI routing |
Comparison reflects out-of-the-box runtime capabilities. Tauri and Electron can reach some of these with third-party plugins and custom code; Forge ships them as the runtime.
The honest answers.
Is this another Electron?
No. Forge drives each platform's native webview (WKWebView, WebView2, WebKitGTK) instead of bundling Chromium, so binaries are small and start fast. More importantly, Forge isn't just a window — the agent planner, tools, memory, and plugin host are part of the runtime.
How is it different from Tauri?
Tauri is an excellent desktop shell. Forge shares the native-webview philosophy but is built agent-first: a planner-executor loop, an MCP tool registry, persistent memory, and a capability protocol are first-class, not things you assemble yourself.
What does "single piece of code" mean exactly?
One Rust project defines your window, your tools, and your agent behavior. The same source compiles to a native installer on macOS, Windows, and Linux — no separate native shells, no per-platform glue code.
Which models can the agent use?
Inference is routed through a backend-agnostic layer. Anthropic is supported for chat and tool use; Ollama adds local chat and embeddings. Configure via environment variables — with none set, agent calls return an explicit, never-silent degraded notice.
Do I have to write the UI in Rust?
No. Point a window at any web UI (your own, or the built-in Studio console) and talk to the runtime over the local JSON-RPC bridge. The agent logic lives in Rust; the surface is whatever you like.
Is it production-ready?
The runtime — native windows, RPC kernel, agent loop, MCP tools, memory, and the WASM plugin host — is wired end-to-end and tested across the workspace. It's early and moving fast; the source is on GitHub.
Can I ship updates without users reinstalling?
Yes. forge update publish signs a delta bundle and pushes it to a named channel (production, beta, etc.). Running installs pick it up automatically via the update.check and update.apply API. You control the rollout percentage — start at 10 %, watch telemetry, then widen to 100 %. If something is wrong, forge update rollback reverts the channel instantly with no user action required.
Does it have build and CI/CD like Expo / EAS?
Yes — that's the platform layer. forge build runs a multi-target profile matrix (macOS, Windows, Linux) and emits a hashed artifact manifest. forge distribute pushes those installers to GitHub Releases, Cloudflare, or a filesystem channel. forge workflow defines the pipeline declaratively: it runs locally today and emits a .github/workflows/release.yml for CI. The whole loop — dev, build, OTA update, distribute, host — is one CLI, every stage backed by a real Rust crate.
Your next desktop app should think.
Clone the repo, define one app, and run it. The window, the kernel, and the agent loop come wired together.
$ git clone https://github.com/hyperbridgedigital/kynetraforge $ cd kynetraforge $ forge start # live window + agent runtime $ forge build --profile production # build for all targets $ forge update publish --channel production # ship a signed OTA update $ forge distribute --tag v1.0.0 # push to GitHub Releases