Is Smoke Monkey an AI model?

No. Smoke Monkey is not an LLM. It is an embeddable, framework-agnostic runtime that turns LLMs (NVIDIA, Gemini, OpenAI, Claude, Ollama) into autonomous engineering agents capable of multi-step planning, calling tools, editing files, and running test loops with zero runtime dependencies.

Do I need a database (Postgres, SQLite, or Redis)?

No database is required. State is persisted through lean session files on disk, or you can plug in your own custom storage adapter. You can deploy it as a CLI, a desktop app, or inside a serverless function without provisioning a database.

How does human-in-the-loop permission gating work?

Smoke Monkey comes with three permission policies: allow-all, deny-all, and ask-default (or a custom function resolver). When a sensitive tool like edit_file or run_command is called under "ask", the runtime emits a permission.required event, pausing execution until your code or UI calls agent.resolvePermission(id, "allow" | "deny").

How does the Model Context Protocol (MCP) server work?

Smoke Monkey ships an official stdio MCP server in smoke-monkey-harness-mcp. Point Claude Code, Cursor, Codex, or opencode at it using npx -y smoke-monkey-harness-mcp to let other AI tools plan, scaffold, verify, and run agents using Smoke Monkey automatically.

What are SKILL.md skills and how do they prevent context bloat?

Skills are directories containing a SKILL.md workflow file. The system prompt only includes a one-line catalog of available skills. When a task requires specialized expertise (e.g. frontend-ui-engineering, test-driven-development, or security-hardening), the agent calls use_skill to load instructions just-in-time, saving thousands of tokens.

What is an AI Agent Harness?

An AI agent harness is the execution environment that bridges raw Large Language Models (LLMs) to real-world software engineering capabilities. While an LLM generates tokens, an AI harness manages deterministic phase loops (explore, plan, edit, verify, recover), tool execution sandboxing, token budget compaction, and safety gates needed for autonomous problem-solving.

What makes Smoke Monkey an Agentic AI runtime rather than a simple wrapper?

Unlike basic prompt-response chains, Smoke Monkey implements true agentic AI architecture: a deterministic 6-phase state machine with automatic failure recovery, runaway loop guards, 24 built-in developer tools, dynamic subcontext isolation, and interactive human-in-the-loop permission pauses.

Is Smoke Monkey Harness 100% Open Source AI?

Yes. Smoke Monkey Harness is 100% open source under the permissive MIT license with zero runtime dependencies. There is no telemetry lock-in, no mandatory cloud backend, and no database requirement—giving engineering teams complete sovereignty over their agent code.

What Agent APIs does Smoke Monkey Harness provide?

Smoke Monkey provides composable TypeScript Agent APIs: createAgent() for initialization, agent.run() for multi-turn execution, agent.on() for fine-grained lifecycle and streaming events, agent.resolvePermission() for interactive human authorization, subcontext switching APIs, and stdio Model Context Protocol (MCP) server endpoints.

Can I run completely offline without API keys?

Yes! Smoke Monkey natively supports Ollama out of the box. Set provider: "ollama" and model: "qwen3:8b" with workspacePath, and the agent will run locally on your machine with zero external network requests.

Desktop Apps

10 min readUpdated: October 2026

Build a Desktop AI Coding Agent with Electron and TypeScript

Technical Review: Smoke Monkey Core Architecture Team

|Tested on Node.js 18+ & Bun|TypeScript 5.x

Quick Answer & Executive Definition

Build a Desktop AI Coding Agent with Electron and TypeScript: Designed as a zero-dependency, open-source TypeScript architecture under the MIT License with native Model Context Protocol (MCP) support and deterministic phase state machines.

Key Architectural Takeaways

Runs 100% offline with Ollama — no internet required after setup
Native file system access for full codebase operations
Ship as a standalone .dmg / .exe without cloud infrastructure
IPC bridge between Electron main and renderer for real-time streaming

Electron + Smoke Monkey Architecture

In an Electron app, Smoke Monkey runs in the main process where it has full Node.js API access. The renderer process (React/HTML UI) communicates via IPC:

Renderer sends user instructions via ipcRenderer.send('agent:run', instruction).
Main process creates an agent and streams events back via ipcMain.on / mainWindow.webContents.send.
Renderer renders the live event stream in the chat UI.

This separation keeps the heavy agent execution away from the UI thread, maintaining a responsive interface.

electron/main.tstypescript

1import { app, BrowserWindow, ipcMain } from 'electron';
2import { createAgent } from 'smoke-monkey-harness';
3
4let mainWindow: BrowserWindow;
5
6ipcMain.on('agent:run', async (event, { instruction, workspacePath }) => {
7  const agent = createAgent({
8    provider: 'ollama',
9    model: 'qwen2.5-coder:7b',
10    workspacePath,
11    autoApprove: false, // Surface permission gates to UI
12  });
13
14  // Stream events to renderer
15  agent.on('tool.started', (e) =>
16    mainWindow.webContents.send('agent:event', { type: 'tool.started', data: e.data })
17  );
18  agent.on('model.streaming', (e) =>
19    mainWindow.webContents.send('agent:event', { type: 'streaming', chunk: e.data.chunk })
20  );
21
22  await agent.run(instruction);
23  mainWindow.webContents.send('agent:event', { type: 'completed' });
24});

Configuring Ollama for Fully Offline Operation

To ship a fully offline desktop agent:

Bundle Ollama in your app's resources, or guide users to install it via the onboarding flow.
Pull the model at first launch if not already cached: run ollama pull qwen2.5-coder:7b via Electron's child_process.
Set `OLLAMA_HOST` in the Electron main process environment before initializing the agent.
Detect Ollama availability and show a setup screen if the local server isn't running.

Use qwen2.5-coder:7b for the best offline coding performance

At 7B parameters, it fits comfortably in 8GB of RAM and runs at 20-40 tokens/second on Apple Silicon — fast enough for a responsive desktop experience.

Google Search Questions & Answers

Frequently Asked Questions

Q:Can I package an Electron agent app for both macOS and Windows?

Yes. Smoke Monkey Harness has no platform-specific native dependencies. Use electron-builder to produce .dmg and .exe artifacts from the same TypeScript codebase.

Q:How do I handle the permission gate UI in Electron?

Subscribe to permission.requested events in the main process and use ipcMain to forward them to the renderer. Render a dialog in React and send the user's decision back via ipcRenderer.send.

Related Alternatives & Comparisons

vs Cursor Composer

Cursor Composer Agent Alternative: Embeddable Code Editing Engine

Compare

vs Cognition Devin

Open Source Devin Alternative: Build Autonomous Software Engineers in TypeScript

Compare

Build with Smoke Monkey Harness

Zero dependencies. 24 built-in tools. Human-in-the-loop safety. 100% open source under the MIT License.

npm install smoke-monkey-harness