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.

DevOps

8 min readUpdated: October 2026

Run AI Agents in CI/CD Pipelines: GitHub Actions & TypeScript Guide

Technical Review: Smoke Monkey Core Architecture Team

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

Quick Answer & Executive Definition

Run AI Agents in CI/CD Pipelines: GitHub Actions & TypeScript Guide: 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

Catch bugs and code smells on every PR before human review
Auto-generate missing unit tests on changed files
Enforce architectural rules with agent-powered linting
Post structured review comments directly to GitHub PRs

Quick Implementation Example.github/workflows/ai-review.yml

.github/workflows/ai-review.ymlyaml

1name: AI Code Review
2
3on:
4  pull_request:
5    types: [opened, synchronize]
6
7jobs:
8  ai-review:
9    runs-on: ubuntu-latest
10    steps:
11      - uses: actions/checkout@v4
12        with:
13          fetch-depth: 0
14
15      - uses: actions/setup-node@v4
16        with:
17          node-version: '20'
18
19      - run: npm install smoke-monkey-harness
20
21      - name: Run AI Code Review
22        env:
23          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
24          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
25        run: node ./.github/scripts/ai-review.ts

Why Run AI Agents in CI/CD?

Traditional CI pipelines run deterministic linters and test suites. AI agents add a reasoning layer that can:

Understand intent, not just syntax — detecting logical bugs that static analysis misses.
Generate context-aware tests for new code paths without manual effort.
Refactor safely by understanding the full codebase, not just the changed diff.
Document automatically by reading the change and updating JSDoc or README sections.

Setting Up the Review Script

Create '.github/scripts/ai-review.ts' in your repository. This script uses the GitHub API to fetch the PR diff, passes it to Smoke Monkey, and posts review comments back.

Use autoApprove: true in CI

Always set autoApprove: true for CI runs. Human-in-the-loop permission gates are designed for interactive sessions, not unattended pipelines.

.github/scripts/ai-review.tstypescript

1import { createAgent } from 'smoke-monkey-harness';
2import { execSync } from 'child_process';
3
4const diff = execSync('git diff origin/main...HEAD').toString();
5const prNumber = process.env.PR_NUMBER;
6
7const agent = createAgent({
8  provider: 'anthropic',
9  model: 'claude-3-7-sonnet',
10  workspacePath: process.cwd(),
11  autoApprove: true, // Non-interactive in CI
12});
13
14const result = await agent.run(
15  `Review this PR diff for bugs, security issues, and missing tests.
16  Output a JSON array of review comments with file, line, and body fields.
17  
18  DIFF:
19  ${diff.slice(0, 8000)}`
20);
21
22// Post comments to GitHub via API
23console.log('Review complete:', result);

Keeping API Keys Safe in GitHub Actions

Store your LLM API key as a GitHub Actions secret:

Go to Settings → Secrets and variables → Actions in your repository.
Click New repository secret.
Name it ANTHROPIC_API_KEY (or OPENAI_API_KEY / GEMINI_API_KEY).
Reference it in your workflow with ${{ secrets.ANTHROPIC_API_KEY }}.

Smoke Monkey reads the key from the environment variable automatically when you set the provider.

Google Search Questions & Answers

Frequently Asked Questions

Q:How do I prevent the agent from making unintended file changes in CI?

Set autoApprove: true but restrict the workspacePath to a read-only checkout, or run the agent in a sandboxed Docker container with no write permissions outside the analysis output directory.

Q:Can I use Smoke Monkey in GitLab CI or Jenkins?

Yes. Any CI system that can run Node.js 18+ can execute Smoke Monkey. Set the LLM API key as a CI/CD variable and run your agent script as a normal pipeline step.

Related Alternatives & Comparisons

vs Cognition Devin

Open Source Devin Alternative: Build Autonomous Software Engineers in TypeScript

Compare

vs Cursor Composer

Cursor Composer Agent Alternative: Embeddable Code Editing Engine

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