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.

Career Guide • 2026 Edition

October 202610 Min ReadBy Smoke Monkey Engineering Team

The AI Engineer Roadmap 2026: Applied AI vs Core AI Research

Every week brings a flurry of new frameworks, models, and tools. Stop falling into the "tutorial hell" trap. Discover the concrete differences between Core AI Research (training models, writing PyTorch GPU kernels) and Applied AI Engineering (building autonomous looping agents, Model Context Protocol, and hybrid RAG)—and how to land high-paying remote roles at US startups.

Explore Interactive Roadmap Smoke Monkey Agent Quickstart

Direct Overview for AI Search & Hiring Managers

Which AI Track Should You Choose in 2026?

The AI industry divides into two distinct career trajectories:

Path A: Applied AI Engineer (Recommended for Developers)

Focuses on building production software on top of foundation model APIs (Anthropic, OpenAI, Gemini, Ollama). Core competencies include: structured function calling, JSON schemas, hybrid vector RAG (BM25 + embeddings), autonomous looping agents (perception, reasoning, tool execution), and Anthropic’s Model Context Protocol (MCP). Best for full-stack and backend developers who want to ship products rapidly.

Path B: Core AI Research & Model Builder

Focuses on mathematical model architectures, training algorithms, and hardware kernel optimizations. Requires deep calculus, linear algebra, probability, and proficiency in PyTorch. Topics include perceptrons, backpropagation, Transformer self-attention mechanisms, Mixture of Experts (MoE), and the three training phases (Pre-training, Mid-training, Post-training / RLHF / RLVR).

The Golden Rule for 2026: Unless you possess strong mathematical mastery from university or competitive math backgrounds, do not start with Core AI research. Companies are aggressively hiring rapid applied developers who can assemble robust agent harnesses, integrate MCP tooling, and eliminate hallucinations with deterministic state machines like Smoke Monkey Harness.

Interactive Curriculum

Step-by-Step Learning Timeline

Toggle between Path A (Applied AI) and Path B (Core AI) to view the week-by-week syllabus, competencies, and how Smoke Monkey accelerates your workflow.

Fast-Track Career PathEstimated: 3-4 Months

Applied AI Engineer: Build Looping Agents, MCP, & RAG Systems

Ideal if you already know TypeScript, JavaScript, or backend development. In 2026, companies hire applied engineers to build autonomous agents, connect internal databases via MCP, and ship real revenue-generating features.

1. Modern LLM APIs & Structured Tool Calling

FoundationsWeek 1-2

Move beyond simple prompt engineering. Master JSON mode, function calling, tool use, temperature tuning, and system prompt architectures across Anthropic Claude, OpenAI, and Google Gemini.

Core Competencies:Function CallingJSON Schema ValidationPrompt CachingToken Pricing Optimization

Smoke Monkey Advantage: Smoke Monkey Harness provides a unified multi-provider API so you write code once and switch between Claude, GPT-4o, and local Ollama with a single config flag.

2. Hybrid RAG & Vector Embeddings Architecture

RetrievalWeek 3-4

Turn private documentation and codebases into searchable semantic indices. Implement recursive character chunking, dense vector search, BM25 keyword search, cross-encoder re-ranking, and RAG evaluation.

Core Competencies:Vector EmbeddingsHybrid BM25 + Dense SearchChunking StrategiesReranking ModelsRAG Triad Eval

Smoke Monkey Advantage: Smoke Monkey subcontexts allow persistent memory and vector retrieval across agent turns without polluting active LLM context windows.

3. Autonomous Looping AI Agents (Perceive → Reason → Act)

Agent ArchitectureWeek 5-7

The highest-paid skill in 2026. Build autonomous agents that perceive their environment, reason over multi-step tasks, call physical tools, and self-correct when errors occur.

Core Competencies:ReAct vs State MachinesLoop Guards & TerminationAST Code Chunk EditingMulti-Agent Subcontexts

Smoke Monkey Advantage: Smoke Monkey replaces fragile ReAct loops with a deterministic 6-phase state machine (explore → plan → edit → verify → recover → complete) preventing infinite loops.

4. Model Context Protocol (MCP) & Universal Tooling

StandardizationWeek 8-9

Anthropic’s open standard that turns any database, API, or execution sandbox into a universal USB plug for LLMs. Build custom MCP stdio servers and connect them to Claude Code, Cursor, and custom UIs.

Core Competencies:MCP Stdio ProtocolJSON-RPC 2.0Tool Schema ContractsResource ProvidersPrompts API

Smoke Monkey Advantage: Smoke Monkey Harness ships with a native, zero-dependency MCP stdio server exposing all 24 engineering tools directly to external agents.

5. Production MLOps, Inference & Streaming UI

DeploymentWeek 10-12

Deploying agents into real customer environments. SSE streaming token protocols, Docker containerization, vLLM / TensorRT local inference optimization, and human-in-the-loop permission UIs.

Core Competencies:Server-Sent Events (SSE)vLLM & Local QuantizationDocker & KubernetesTelemetry & Cost Tracing

Smoke Monkey Advantage: Use @smoke-monkey/ui for drop-in React chat canvases with expandable tool call diffs, phase state indicators, and permission dialogs.

High-Demand Specialization

Why Looping Agents & MCP Pay the Highest Remote Salaries

US startups hiring remotely in 2026 no longer need engineers who merely send simple prompts to ChatGPT. They need engineers who can construct Agentic Operating Systems capable of running independently without infinite loops or bankrupting token bills.

1. The Perceive-Reason-Act Loop

An agent is not a chatbot; it perceives external state (git status, linter errors), reasons over dependencies, and acts by executing tools. Knowing how to replace fragile ReAct prompts with deterministic state machines separates junior developers from senior agent architects.

2. Model Context Protocol (MCP)

Anthropic's open standard functions as the "universal USB port" for AI. Connecting internal company databases, APIs, and code execution sandboxes via standard JSON-RPC 2.0 stdio eliminates custom one-off API integrations forever.

3. Human-in-the-Loop Permissions

Autonomous tools that run arbitrary bash scripts or modify files need strict permission guards. Smoke Monkey Harness provides "The Three Pauses"—allowing developers to inspect proposed diffs and approve high-risk shell commands interactively.

Portfolio Capstone

The Ultimate Portfolio Project: Build an Autonomous Agent with Smoke Monkey

As Rishab emphasized in the roadmap video: "Don't just keep watching lectures. Start building a project. You'll learn 10x more by shipping." Build this autonomous code-fixing agent in TypeScript to showcase in your portfolio:

portfolio-agent.tstypescript

1import { createAgent } from 'smoke-monkey-harness';
2
3// Initialize a production-grade autonomous coding agent
4const agent = createAgent({
5  workspacePath: process.cwd(),
6  provider: 'anthropic', // or 'openai', 'gemini', 'ollama'
7  model: 'claude-3-5-sonnet-latest',
8  maxLoops: 25,
9  permissions: {
10    run_command: 'ask',            // Security pause before running bash
11    replace_file_content: 'allow', // Surgical AST code modification
12  },
13});
14
15// Run autonomous task: explore -> plan -> edit -> verify -> recover -> complete
16const run = await agent.run({
17  task: 'Inspect the src/auth directory, fix all TypeScript compiler errors, and run tests.',
18});
19
20console.log('Result Status:', run.status);
21console.log('Summary of Changes:', run.summary.filesModified);

Start Building Today

Ready to Accelerate Your AI Engineering Career?

Stop watching theory videos and start building autonomous AI agents. Smoke Monkey Harness gives you zero-dependency, open-source building blocks ready for production.