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 Phidata (Agno)

Python Agent FrameworkUpdated: October 2026

Phidata Alternative: Lightweight TypeScript Agent Without Python Infrastructure

Phidata (rebranded as Agno) requires Postgres, vector databases, and Python virtual environments even for simple agent tasks. Smoke Monkey Harness is the TypeScript-native alternative with zero runtime dependencies and no database setup.

Comparative Benchmark: Smoke Monkey Harness TypeScript vs Phidata (Agno)

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

The Executive Verdict (Quick Answer)

Why choose Smoke Monkey over Phidata (Agno)? Choose Smoke Monkey Harness if you want a clean TypeScript agent harness that works out of the box on Node.js 18+ without provisioning databases, installing Python, or configuring container orchestration.

Why Developers Switch from Phidata (Agno) to Smoke Monkey

Zero Database Requirement: No Postgres, SQLite, or vector DB needed for agent memory or state.

TypeScript Native: No Python virtual environment or pip install complexity.

Instant Setup: npm install + 15 lines of TypeScript and your agent runs.

100% MIT Licensed: No upselling to cloud SaaS tiers or paid monitoring.

Detailed Feature-by-Feature Matrix

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

Capability	Smoke Monkey Harness	Phidata (Agno)	Key Architectural Difference
Language	✅ 100% TypeScript / Node.js	❌ Python-first (experimental TS)	First-class Next.js and Electron integrations.
Database Requirement	✅ None (flat JSON sessions on disk)	❌ Postgres or SQLite required for memory	No infrastructure provisioning needed.
MCP Support	✅ Native stdio client & server	⚠️ Experimental	Full integration with Claude Code, Cursor, Windsurf.

Code Implementation Comparison

Creating a Simple Agent

Smoke Monkey (TypeScript)Zero Dependencies

smoke-monkey.tstypescript

1import { createAgent } from 'smoke-monkey-harness';
2
3// No database. No Python. No Docker.
4const agent = createAgent({
5  provider: 'gemini',
6  model: 'gemini-1.5-pro',
7  workspacePath: process.cwd(),
8  autoApprove: true,
9});
10
11await agent.run('Refactor API handlers to use async/await uniformly');

Phidata (Agno)Python + Postgres Required

phidata_agent.pypython

1from phi.agent import Agent
2from phi.model.openai import OpenAIChat
3from phi.storage.agent.postgres import PgAgentStorage
4
5# Requires Postgres database
6agent = Agent(
7    model=OpenAIChat(id='gpt-4o'),
8    storage=PgAgentStorage(
9        table_name='agent_sessions',
10        db_url='postgresql://...'
11    ),
12    add_history_to_messages=True,
13)
14agent.print_response('Refactor API handlers')

Architecture Note: Smoke Monkey runs completely database-free, making it far simpler to deploy in serverless and edge environments.

Why Databases Are an Unnecessary Burden for Most Agents

Session persistence for agentic loops rarely requires relational databases. Smoke Monkey stores session context, tool execution logs, and conversation histories in structured JSON files, which are fast, portable, and deployable anywhere Node.js runs. For production apps that need custom persistence, Smoke Monkey provides a clean storage adapter interface.

Frequently Asked Questions

Questions Developers Ask About Phidata (Agno) Alternatives

Q:Does Smoke Monkey support long-term agent memory like Phidata?

Yes. Session files persist agent memory between runs. For advanced semantic memory, you can connect any vector database through custom tools or MCP server integrations.

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