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.

Smoke Monkey vs Google Gemini 4 Argon & Vertex AI

Restricted Frontier Cloud Model ($1.50-$10.00/M tokens)Updated: October 2026

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

Google's October 2026 launch of **Gemini 4 Argon** represents their most powerful frontier reasoning model to date, initially rolled out with selective restrictions to cybersecurity experts and enterprise research partners. While Gemini 4 Argon delivers unprecedented vulnerability diagnosis, multi-step algorithmic reasoning, and 2M token context, relying solely on Google Cloud Vertex AI locks engineering teams behind restricted access tiers, cloud telemetry surveillance, and metered enterprise billing. Smoke Monkey Harness delivers a 100% open-source, MIT-licensed runtime that seamlessly connects to Gemini 4 Argon and Gemini 2.5 APIs, while enforcing local human-in-the-loop permission gates, surgical AST code editing, and automatic offline fallback to local models like Gemma 3 and DeepSeek R1.

Comparative Benchmark: Smoke Monkey Harness TypeScript vs Google Gemini 4 Argon & Vertex AI

|Verified for Node.js 18+ & Bun|100% MIT Open Source

The Executive Verdict (Quick Answer)

Why choose Smoke Monkey over Google Gemini 4 Argon & Vertex AI? Choose Smoke Monkey Harness to harness Gemini 4 Argon's breakthrough reasoning capabilities without cloud lock-in or access bottlenecks. You gain a deterministic 6-phase state machine with 24 native dev tools, local sandbox protection, and the flexibility to switch between Google, Anthropic Claude 3.7, OpenAI o3, and air-gapped offline models with a single line of TypeScript.

Why Developers Switch from Google Gemini 4 Argon & Vertex AI to Smoke Monkey

Access Freedom & Multi-Model Agility: When Gemini 4 Argon access is restricted or rate-limited, fail over instantly to Anthropic Claude 3.7, OpenAI o3, or local Gemma 3.

100% Sovereign & MIT Licensed: Zero cloud seat subscriptions or runtime markups. You own your prompts, memory files, and execution state.

Active Dev Tool Superpowers: Rather than passive cloud chat boxes, Smoke Monkey equips Gemini 4 Argon with 24 local tools (AST chunk diffs, bash terminal, git).

Offline Air-Gapped Privacy: Fall back to local open weights via Ollama (Gemma 3, DeepSeek R1) for sensitive proprietary codebases that cannot be transmitted to external servers.

The 3 Safety Pauses: Intercept destructive commands (rm, git push, deployment triggers) with interactive human confirmation cards.

Detailed Feature-by-Feature Matrix

Direct side-by-side comparison of core runtime capabilities and architectural trade-offs.

Capability	Smoke Monkey Harness	Google Gemini 4 Argon & Vertex AI	Key Architectural Difference
Model Support & Agnostic Freedom	✅ 18 Providers: Gemini 4 Argon, Claude 3.7, OpenAI o3, Ollama, DeepSeek	❌ Google Cloud Vertex AI & Gemini ecosystem lock-in	Switch between Google frontier models and local offline weights dynamically.
Pricing & Licensing	✅ 100% Free & Open Source (MIT License)	❌ Metered Google Cloud billing + Vertex AI enterprise fees	Zero platform markups or recurring seat costs.
Local Offline Execution	✅ Native Ollama support (Gemma 3, DeepSeek R1, Llama 3.3)	❌ Impossible (Requires active Google Cloud connection and API keys)	Air-gapped execution keeps proprietary codebase strictly on-premise.
Autonomous State Machine	✅ Deterministic 6-Phase Loop (Explore → Plan → Edit → Verify → Recover → Complete)	❌ Single-turn chat completion or proprietary ADK graph	Automatically diagnoses compiler errors and refactors code in verified steps.
Native Filesystem & Dev Tools	✅ 24 Built-In Tools (AST chunk replacement, bash, ripgrep, git)	❌ Raw text generation requiring manual developer copy-paste	Edits files with syntax verification and runs local unit test suites directly.
Model Context Protocol (MCP)	✅ Native Stdio & HTTP MCP Server / Client Hub	❌ Proprietary Google Cloud extension ecosystem	Connects directly to Cursor, Claude Code, Windsurf, and custom tool networks.
Human-in-the-Loop Safety	✅ The 3 Pauses (ask_permission, ask_question, notify_user)	❌ Unchecked autonomous loops or basic confirmation callbacks	Gives engineers surgical veto power over commands like rm, git push, or npm publish.
Embeddable UI Component	✅ Drop-in React Chat Canvas (@smoke-monkey/ui)	❌ Google Cloud Console or complex Vertex AI web widgets	Embed real-time streaming, timeline inspection, and approval cards into any app.

Code Implementation Comparison

Connecting to Google Gemini 4 Argon in Smoke Monkey vs Proprietary Vertex AI

Smoke Monkey (TypeScript)Zero Dependencies

gemini-4-argon-agent.tstypescript

1import { createAgent } from 'smoke-monkey-harness';
2
3// 1. Initialize autonomous agent with Google's 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',    // Intercept risky terminal commands
10    write_file: 'allow',    // Allow surgical AST edits
11  },
12  // Multi-model resilience: fallback to local Gemma 3 if restricted
13  fallback: {
14    provider: 'ollama',
15    model: 'gemma-3:8b',
16  },
17});
18
19// 2. Run self-healing cybersecurity refactor loop
20const result = await agent.run('Audit codebase for prototype pollution vulnerabilities and apply AST patches');
21console.log('Finished with status:', result.status);

Google Gemini 4 Argon & Vertex AIRestricted Access & Cloud Lock-In

google-vertex-lockin.tstypescript

1// Closed Google Cloud Vertex AI SDK
2import { VertexAI } from '@google-cloud/vertexai';
3
4const vertex = new VertexAI({ project: 'restricted-cyber-project', location: 'us-central1' });
5const model = vertex.getGenerativeModel({ model: 'gemini-4-argon' });
6
7// Passive text generation - cannot execute bash or edit files directly
8const chat = model.startChat();
9const response = await chat.sendMessage('Please audit authentication middleware');
10// Developer must manually copy-paste code and write custom tool runners

Architecture Note: Smoke Monkey Harness wraps Gemini 4 Argon in an active, self-correcting 6-phase engineering state machine with 24 native dev tools and local Gemma 3 fallback, whereas raw Google Cloud APIs require writing thousands of lines of custom tooling and platform boilerplate.

Architecture Breakdown: Gemini 4 Argon vs Smoke Monkey Multi-Model Harness

Google Gemini 4 Argon vs Smoke Monkey Multi-Model Agent Harness Architecture

Google's October 2026 release of Gemini 4 Argon introduces an advanced frontier reasoning core designed specifically for high-stakes problem solving, complex vulnerability identification, and multi-turn architectural synthesis. However, deploying raw models in unconstrained environments poses critical security risks. As illustrated above, Smoke Monkey Harness sandwiches frontier intelligence like Gemini 4 Argon within a deterministic 6-phase state machine (Explore, Plan, Edit, Verify, Recover, Complete) alongside 24 native developer tools and local offline fallback models (Gemma 3 and DeepSeek R1).

Why Google Restricted Gemini 4 Argon Access (And How to Maintain Resilience)

Google's selective rollout of Gemini 4 Argon reflects heightened caution around dual-use reasoning capabilities, particularly autonomous exploit generation and automated penetration testing. While enterprise cybersecurity teams gain early access, broad general developer availability remains controlled. By using Smoke Monkey Harness, your engineering workflows never stall. You can configure Gemini 4 Argon as the primary reasoning engine, with automatic fallback cascades to Anthropic Claude 3.7 Sonnet, OpenAI o3, or local offline Gemma 3 instances running privately via Ollama.

Deterministic Agentic Execution: Why Frontier Reasoning Needs State Machines

Even the most advanced reasoning models can degrade into infinite loops or hallucinated tool arguments when left in unconstrained ReAct loops. Smoke Monkey Harness provides rigid architectural bounds: AST file editing guarantees that only targeted code blocks are modified, shell execution is strictly sandboxed, and test verification gates ensure that code changes compile and pass test suites before an agent task can complete.

Frequently Asked Questions

Questions Developers Ask About Google Gemini 4 Argon & Vertex AI Alternatives

Q:What is Google Gemini 4 Argon and when was it released?

Gemini 4 Argon was released in October 2026 as Google's latest frontier reasoning model, featuring specialized breakthroughs in complex multi-step reasoning, mathematical proofs, and cybersecurity vulnerability analysis.

Q:How do I configure Gemini 4 Argon in Smoke Monkey Harness?

Set your GEMINI_API_KEY environment variable and configure provider: "gemini" with model: "gemini-4-argon". Smoke Monkey Harness automatically handles streaming, function calling, and token budgeting.

Q:What happens if my team does not yet have Gemini 4 Argon API access?

Smoke Monkey Harness is provider-agnostic. You can instantly run Gemini 2.5 Flash, Claude 3.7 Sonnet, OpenAI o3, or free local models (DeepSeek R1, Gemma 3) with zero code changes—simply change the model string in your configuration.

Q:Does Smoke Monkey Harness charge extra fees on top of Google API costs?

No. Smoke Monkey Harness is 100% free and open-source under the MIT license. You pay zero platform markups, seat fees, or subscription tiers.

Q:How does Smoke Monkey Harness prevent unauthorized destructive commands?

Smoke Monkey Harness implements The 3 Pauses (ask_permission, ask_question, notify_user). Commands like rm, git push, or production deployments pause the loop and present an interactive approval modal.

Q:Can I run Google's open-source Gemma 3 model completely offline?

Yes! Pair Smoke Monkey Harness with local Ollama (`ollama run gemma-3:8b`) for 100% private, air-gapped execution with zero data leaving your machine.

Switch to Smoke Monkey Harness Today

Build autonomous coding agents with zero runtime dependencies, deterministic 6-phase loops, and Model Context Protocol (MCP) in pure TypeScript.

npm install smoke-monkey-harness