MyCoder.ai — Summary

MyCoder is a command-line AI coding agent (npm package mycoder) that spawns parallel sub-agents for concurrent task processing, supporting multiple model providers (Anthropic Claude, OpenAI, Ollama). Installed globally via npm install -g mycoder, it runs as its own runtime rather than a plugin layer on top of another tool. The agent system includes a rich tool set: shell execution, text editor, browser/fetch, MCP servers, sleep, think, and an agentStart/agentDone tool pair that explicitly spawns and tracks sub-agents with unique IDs. GitHub integration mode lets it work directly with issues and PRs; interactive corrections via Ctrl+M mid-run allow human steering. Context window management includes automatic message compaction for long-running agents.

Differs from seeds: closest to claude-flow in spawning parallel sub-agents at runtime for concurrent execution, but MyCoder is a standalone CLI tool (not a Claude Code plugin) and is model-agnostic across three provider families. Unlike taskmaster-ai (which decomposes a spec into tasks) or openspec (which writes delta specs), MyCoder is an autonomous executor that reads project files, writes code, and manages its own sub-agent lifecycle end-to-end without a formal spec layer.

MyCoder.ai — Overview

Origin

MyCoder is developed by DriveCore (github.com/drivecore/mycoder) under the MIT license. The project is a monorepo with three packages: mycoder (CLI), mycoder-agent (core agent library), and mycoder-docs (documentation site). Version analyzed: last commit 2026-01-07. The tool is distributed as a global npm package and described as "Simple to install, powerful command-line based AI agent system for coding."

Philosophy

MyCoder's philosophy centers on autonomous parallel execution with human-in-the-loop correction:

• Parallel Execution: Sub-agents are spawned for concurrent task processing, reducing wall-clock time
• Human Compatible: Reads README.md, project files, and runs shell commands to build its own context — no special setup files needed
• Self-Modification: Can modify its own code; was built and tested by writing itself
• Interactive Corrections: Users can send corrections mid-run without stopping the agent (Ctrl+M)
• Message Compaction: Automatically manages context window for long-running agents

Manifesto-Style Quotes

From README:

"Simple to install, powerful command-line based AI agent system for coding."

"AI-Powered: Leverages Anthropic's Claude, OpenAI models, and Ollama for intelligent coding assistance"

"Self-Modification: Can modify code, it was built and tested by writing itself"

"Human Compatible: Uses README.md, project files and shell commands to build its own context"

GitHub Comment Commands

MyCoder extends into GitHub workflows via comment commands:

"/mycoder implement a PR for this issue"
"/mycoder create an implementation plan"
"/mycoder suggest test cases for this feature"

This enables trigger-from-issue automation without a separate orchestration layer.

MyCoder.ai — Architecture

Distribution

• npm package: mycoder — global install
• Monorepo: packages/cli, packages/agent, packages/docs
• Supported providers: Anthropic Claude, OpenAI models, Ollama (local)

Install

npm install -g mycoder

Repository Structure

packages/
  cli/
    bin/             # CLI entry point (mycoder binary)
    mycoder.config.js
  agent/
    src/
      core/
        toolAgent/
          toolAgentCore.ts    # Main agent loop
          config.ts           # System prompt + agent config
      tools/
        agent/                # agentStart, agentDone, agentMessage, agentExecute, listAgents
        fetch/                # HTTP fetch tool
        interaction/          # userPrompt tool
        mcp.ts                # MCP server integration
        session/              # Session management
        shell/                # Shell command execution
        sleep/                # Sleep/wait tool
        textEditor/           # File editing tool
        think/                # Internal reasoning tool
        utility/              # Utility tools
  docs/               # Documentation website

Required Runtime

• Node.js (recent LTS)
• npm/pnpm
• Git (for GitHub mode)
• Optional: Ollama (for local model support)

Configuration

MyCoder supports 7 configuration file locations in priority order:

1. mycoder.config.js in project root
2. .mycoder.config.js in project root
3. .config/mycoder.js in project root
4. .mycoder.rc in project root
5. .mycoder.rc in home directory
6. mycoder field in package.json
7. ~/.config/mycoder/config.js (XDG standard)

Supported formats: .js, .ts, .mjs, .cjs, .json, .jsonc, .json5, .yaml, .yml, .toml

Target AI Tools

Standalone CLI — not a plugin for Claude Code or Cursor. Supports:

• Anthropic Claude (default: claude-3-7-sonnet-20250219)
• OpenAI models
• Ollama (local, via baseUrl: 'http://localhost:11434')

Key Config Options

{
  provider: 'anthropic',
  model: 'claude-3-7-sonnet-20250219',
  maxTokens: 4096,
  temperature: 0.7,
  githubMode: true,
  headless: true,
  interactive: true,
  mcp: { servers: [...] }
}

MyCoder.ai — Components

CLI Binary

mycoder — global npm binary with the following invocation modes:

• mycoder -i — interactive mode
• mycoder "prompt" — single prompt run
• mycoder -f prompt.txt — run from file
• mycoder --interactive "prompt" — with Ctrl+M corrections
• mycoder --userPrompt false "prompt" — fully automated (no user prompts)
• mycoder --upgradeCheck false "prompt" — no version check (CI-safe)

Agent Tools (from packages/agent/src/tools/)

Sub-Agent System

The agentStart tool accepts:

• description — brief purpose (max 80 chars)
• goal — main objective
• projectContext — environment context
• workingDirectory — optional working dir
• relevantFilesDirectories — glob patterns
• userPrompt — whether sub-agent can prompt user (default false)

Returns agentId for tracking. Sub-agents run with the same tool set as the parent.

MCP Support

MyCoder can connect to any MCP server via config:

mcp: {
  servers: [{ name: 'example', url: '...', auth: {...} }],
  defaultResources: [...],
  defaultTools: [...]
}

Context Management

• Reads README.md, project files, shell output to build context naturally
• No special context files required
• session/ tool handles message compaction when context window pressure grows

GitHub Integration

githubMode: true enables:

• Working with GitHub issues and PRs
• Comment-triggered automation (/mycoder <instruction>)
• PR creation and issue closing

MyCoder.ai — Uniqueness & Positioning

Differs From Seeds

Closest to claude-flow in spawning parallel sub-agents for concurrent execution. The architectural delta: MyCoder is a standalone CLI tool (not a Claude Code plugin) that supports three model providers (Anthropic, OpenAI, Ollama), uses schema-constrained tool calls (Zod) for sub-agent spawning, and requires no special project setup files — it reads README.md and project files organically. Unlike taskmaster-ai (spec → tasks) or kiro (spec-driven interactive workflow), MyCoder has no formal spec or planning layer; the agent plans internally via the think tool. Unlike agent-os or openagentscontrol (both requiring context file setup), MyCoder is context-file-free.

Distinctive Opinion

"Human Compatible: Uses README.md, project files and shell commands to build its own context."

The anti-pattern is explicit: no setup friction. MyCoder bets that a well-written README + project structure is sufficient context for productive coding agents, rather than requiring teams to author dedicated context files.

The agentStart/agentDone pair is a first-class parallel execution primitive, not a workaround — MyCoder treats concurrent sub-agents as the standard mode for complex tasks.

Positioning

MyCoder targets developers who want a powerful autonomous coding agent without setup overhead. It is more autonomous than OAC (no mandatory approval gates) and more provider-flexible than tools locked to Claude. GitHub comment triggers position it for teams wanting asynchronous issue-driven development.

Observable Failure Modes

1. Context drift: Without structured context files, sub-agents may make different assumptions about project patterns, leading to inconsistent code across parallel executions.
2. No corpus compounding: Each session starts fresh. Teams cannot leverage accumulated decisions or learnings the way AgentOps does.
3. Shallow validation: No built-in adversarial reviewer or multi-judge consensus. Quality depends on the main agent's self-checking.
4. Dormancy: Last commit was 2026-01-07 — project may be in maintenance mode given competitive field.
5. Sub-agent isolation gap: Sub-agents share the filesystem but have no shared state mechanism. Race conditions on shared files are possible in parallel runs.

Cross-References

• Website: mycoder.ai (marketing site) + docs.mycoder.ai (docs)
• Discord: discord.gg/5K6TYrHGHt
• Mentions Ollama support positioning it for local/private model use