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.

Integrations & Tools

7 min readUpdated: October 2026

Google New Model Launch: Architecting Autonomous AI Agents with Gemini 4 Argon & Gemma 3

Google's October 2026 launch of **Gemini 4 Argon** introduces an elite frontier reasoning architecture with enhanced cybersecurity safeguards and deep analytical synthesis. This technical implementation guide shows how to architect production-grade autonomous coding agents in TypeScript using Smoke Monkey Harness, combining Gemini 4 Argon's advanced reasoning with 24 native engineering tools, local Gemma 3 offline fallback, and zero cloud vendor lock-in.

Technical Review: Smoke Monkey Core Architecture Team

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

Quick Answer & Executive Definition

Google New Model Launch: Architecting Autonomous AI Agents with Gemini 4 Argon & Gemma 3: Google's October 2026 launch of **Gemini 4 Argon** introduces an elite frontier reasoning architecture with enhanced cybersecurity safeguards and deep analytical synthesis. This technical implementation guide shows how to architect production-grade autonomous coding agents in TypeScript using Smoke Monkey Harness, combining Gemini 4 Argon's advanced reasoning with 24 native engineering tools, local Gemma 3 offline fallback, and zero cloud vendor lock-in. 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

Gemini 4 Argon Architecture: Master Google's newest frontier reasoning model with native tool execution, streaming, and subcontext memory management.
Sovereign Multi-Model Runtimes: Eliminate cloud lock-in by pairing Gemini 4 Argon with Anthropic Claude 3.7, OpenAI o3, and local Ollama models.
Local Gemma 3 & DeepSeek Fallback: Maintain 100% uptime with automated zero-cost offline fallbacks when cloud API limits or restrictions occur.
24 Native Developer Tools: Equip Gemini 4 Argon with surgical AST chunk editing, bash command execution, and automated test verification.

Quick Implementation Examplegemini-4-argon-quickstart.ts

gemini-4-argon-quickstart.tstypescript

1import { createAgent } from 'smoke-monkey-harness';
2
3// Initialize an autonomous agent with Google's new Gemini 4 Argon reasoning model
4const agent = createAgent({
5  provider: 'gemini',
6  model: 'gemini-4-argon',
7  workspacePath: process.cwd(),
8  permissions: {
9    run_command: 'ask',    // Prompt before shell commands
10    write_file: 'allow',    // Allow surgical AST edits
11  },
12  fallback: {
13    provider: 'ollama',
14    model: 'gemma-3:8b',    // Offline local fallback
15  },
16});
17
18// Execute self-healing developer workflow
19const result = await agent.run('Audit repository dependencies, repair CVE vulnerabilities, and verify test suite');
20console.log('Result status:', result.status);

Deconstructing the Gemini 4 Argon Launch: Frontier Reasoning Meets Agentic AI

Google New Model Launch 2026: Gemini 4 Argon & Autonomous Agent Harness Architecture

Released in October 2026, Gemini 4 Argon is Google's most capable reasoning model to date. Specifically designed for high-complexity engineering domains, Argon features deep analytical planning, advanced symbolic reasoning, and rigorous cybersecurity scrutiny. In benchmarking evaluations, Argon excels at diagnosing subtle concurrency defects, parsing complex architectural dependency graphs, and synthesizing secure code modifications across multi-thousand-line repositories.

Selective Access & Cybersecurity Safeguards

Due to Argon's advanced reasoning and automated exploit analysis capabilities, Google has implemented staged access controls. Smoke Monkey Harness allows teams to seamlessly integrate Argon where available while automatically routing tasks to alternative models when needed.

Why Cloud SDKs Limit Agent Autonomy: Moving Beyond Vertex AI

While Google Cloud Vertex AI provides a hosted environment, its SDKs are designed primarily for request-response chat applications rather than autonomous agentic workflows. Developers attempting to build agents directly with raw Google APIs face significant hurdles: lack of deterministic loop management, no built-in AST code editing capabilities, tedious manual tool calling schemas, and severe cloud vendor lock-in. Smoke Monkey Harness decouples model intelligence from platform plumbing, giving you a sovereign TypeScript runtime that treats Gemini 4 Argon as a pluggable reasoning engine while managing tools, state, and permissions locally.

Configuring Gemini 4 Argon with Local Gemma 3 Fallback in Smoke Monkey

In production engineering environments, API rate limits, network interruptions, or transient cloud outages can disrupt autonomous workflows. Smoke Monkey Harness includes native multi-provider fallback. By pairing cloud-hosted Gemini 4 Argon with local Gemma 3 or DeepSeek R1 running in Ollama, your agents can continue executing offline file edits, git inspections, and compiler diagnostics without interruption.

resilient-argon-agent.tstypescript

1import { createAgent } from 'smoke-monkey-harness';
2
3export const devAgent = createAgent({
4  provider: 'gemini',
5  model: 'gemini-4-argon',
6  apiKey: process.env.GEMINI_API_KEY,
7  fallback: {
8    provider: 'ollama',
9    model: 'gemma-3:8b', // Free local open weights
10  },
11  maxIterations: 30,
12  workspacePath: process.cwd(),
13});

Empowering Google Models with 24 Native Engineering Tools

A model is only as effective as the tools it can operate. Smoke Monkey Harness provides Gemini 4 Argon with 24 built-in developer tools categorized into file discovery, AST chunk editing, shell command execution, git operations, and human permission requests. Rather than regenerating entire files—which wastes tokens and introduces syntax errors—the agent uses AST chunk replacements to surgically modify only the affected functions.

Google Search Questions & Answers

Frequently Asked Questions

Q:Which Google models are supported in Smoke Monkey Harness?

Smoke Monkey Harness supports all current Google Gemini models (Gemini 4 Argon, Gemini 2.5 Flash, Gemini 2.5 Pro, Gemini 2.0 Flash) via API keys, as well as open-weights Gemma 2 and Gemma 3 models via local Ollama.

Q:Do I need a Google Cloud Vertex AI account to use Gemini 4 Argon?

No! You can use standard Google AI Studio API credentials (GEMINI_API_KEY) with zero Google Cloud project configuration or complex GCP IAM roles required.

Q:How does Smoke Monkey Harness prevent runaway agent loops?

Smoke Monkey enforces maxIterations limits, token compaction thresholds, and deterministic state transitions (Explore → Plan → Edit → Verify → Recover). If an agent fails to make progress after 3 attempts, it triggers the Recover phase to ask for human guidance.

Q:Can I expose my Gemini agent as an MCP server to Cursor or Claude Code?

Yes! Smoke Monkey Harness includes a built-in Model Context Protocol (MCP) server. You can run `npx smoke-monkey-harness-mcp` to expose your Gemini agent and local tools directly to Cursor, Claude Code, or Windsurf.

Related Alternatives & Comparisons

vs Google Gemini 4 Argon & Vertex AI

Google New Model Launch: Gemini 4 Argon & Gemini 2.5 vs Sovereign Agent Harness (2026)

Compare

vs Google Agent Development Kit (ADK)

Google Agent Development Kit (ADK) Alternative: Multi-Model Open Source Harness

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