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.
- 3
- platforms, one source
- 1
- native binary, no Node
- 0
- glue between brain & hands
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.
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 |
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.
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 dev # live window + agent runtime $ forge bundle # native installer for your platform