BranchesTags

Repository files navigation

DockaShell

DockaShell is an MCP (Model Context Protocol) server that gives AI agents isolated Docker containers to work in. Each agent gets its own persistent environment with shell access, file operations, and full audit trails.

This is a research project exploring agent autonomy: How far can we push shell-based workflows? Can agents manage their own development environments and create their own tools?

Why this exists

Current AI assistants hit fundamental walls:

  • No persistent memory: Conversations reset, context is lost, agents can't build on previous work
  • Tool babysitting: Every shell command needs human approval, breaking agent flow and autonomy
  • Limited toolsets: Agents stuck with predefined tools instead of building what they need
  • No self-reflection: Can't analyze their own traces to improve or learn from past sessions

DockaShell removes these constraints to explore what emerges:

  • Self-evolving agents: Build and refine their own tools, scripts, and workflows
  • Continuous memory: Maintain knowledge bases, wikis, notebooks that persist across sessions
  • Autonomous exploration: Run shell commands without constant human intervention
  • Meta-learning: Analyze previous traces to improve decision-making and tool usage

The core question: What can agents accomplish when they have real persistence and autonomy?

How it works

AI Agent (Claude/GPT/...)
↔ DockaShell (MCP Server)
└─ Docker Engine
├─ Container A (Project 1)
│ └─ Persistent Volume
├─ Container B (Project 2)
│ └─ Persistent Volume
└─ Container C (Project 3)
└─ Persistent Volume

Each AI agent gets its own isolated Docker container with persistent storage. Instead of dozens of custom tools, agents use standard shell commands (bash, git, npm, etc.) and build their own workflows.

Key principles:

  • Shell > specialized tools: Agents already "speak" POSIX, so let them use real commands
  • Container isolation: Full autonomy inside, zero risk to your host system
  • Persistent workspace: Files, databases, and context survive across sessions
  • Complete audit trail: Every command and file change is logged for analysis

→ See detailed architecture and security model

Quick Start

# Install
npm install -g dockashell
# Setup
dockashell build
dockashell create my-project
dockashell start my-project

Add to your MCP client configuration:

{
"mcpServers": {
"dockashell": {
"command": "dockashell",
"args": ["serve"]
}
}
}

Requirements: Node.js 20+, Docker running

Example workflows

Data analysis: Agent spins up Python environment, processes CSV files, generates insights

Web development: Agent builds React app, installs dependencies, runs dev server with live preview

Research assistant: Agent tracks information across sessions, maintains SQLite databases, remembers context

Documentation

Current state

This is active research, not production software. The core functionality works well for experimentation, but expect changes as I explore what agents can do with persistent shell environments.

Contributions and feedback welcome.

License

Apache License 2.0

About

DockaShell is an MCP server that gives AI agents isolated Docker containers to work in. MCP tools for shell access, file operations, and full audit trail.

Topics

agentcoding-agentdockermcpmodel-context-protocolvibe-coding

Resources

Readme
Apache-2.0 license
Activity

Stars

30 stars

Watchers

2 watching

Forks

7 forks
Report repository

Releases

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
DockaShell
DockaShell is an MCP (Model Context Protocol) server that gives AI agents isolated Docker containers to work in. Each agent gets its own persistent environment with shell access, file operations, and full audit trails.
This is a research project exploring agent autonomy: How far can we push shell-based workflows? Can agents manage their own development environments and create their own tools?
Why this exists
Current AI assistants hit fundamental walls:
  • No persistent memory: Conversations reset, context is lost, agents can't build on previous work
  • Tool babysitting: Every shell command needs human approval, breaking agent flow and autonomy
  • Limited toolsets: Agents stuck with predefined tools instead of building what they need
  • No self-reflection: Can't analyze their own traces to improve or learn from past sessions
DockaShell removes these constraints to explore what emerges:
  • Self-evolving agents: Build and refine their own tools, scripts, and workflows
  • Continuous memory: Maintain knowledge bases, wikis, notebooks that persist across sessions
  • Autonomous exploration: Run shell commands without constant human intervention
  • Meta-learning: Analyze previous traces to improve decision-making and tool usage
The core question: What can agents accomplish when they have real persistence and autonomy?
How it works
AI Agent (Claude/GPT/...)
↔ DockaShell (MCP Server)
└─ Docker Engine
├─ Container A (Project 1)
│ └─ Persistent Volume
├─ Container B (Project 2)
│ └─ Persistent Volume
└─ Container C (Project 3)
└─ Persistent Volume

Each AI agent gets its own isolated Docker container with persistent storage. Instead of dozens of custom tools, agents use standard shell commands (bash, git, npm, etc.) and build their own workflows.
Key principles:
  • Shell > specialized tools: Agents already "speak" POSIX, so let them use real commands
  • Container isolation: Full autonomy inside, zero risk to your host system
  • Persistent workspace: Files, databases, and context survive across sessions
  • Complete audit trail: Every command and file change is logged for analysis
→ See detailed architecture and security model
Quick Start
# Install
npm install -g dockashell
# Setup
dockashell build
dockashell create my-project
dockashell start my-project
Add to your MCP client configuration:
{
"mcpServers": {
"dockashell": {
"command": "dockashell",
"args": ["serve"]
}
}
}
Requirements: Node.js 20+, Docker running
Example workflows
Data analysis: Agent spins up Python environment, processes CSV files, generates insights
Web development: Agent builds React app, installs dependencies, runs dev server with live preview
Research assistant: Agent tracks information across sessions, maintains SQLite databases, remembers context
Documentation
Current state
This is active research, not production software. The core functionality works well for experimentation, but expect changes as I explore what agents can do with persistent shell environments.
Contributions and feedback welcome.
License
Apache License 2.0
About
DockaShell is an MCP server that gives AI agents isolated Docker containers to work in. MCP tools for shell access, file operations, and full audit trail.
Topics
agentcoding-agentdockermcpmodel-context-protocolvibe-coding
Resources
Readme
Apache-2.0 license
Activity
Stars
30 stars
Watchers
2 watching
Forks
7 forks
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
DockaShell
DockaShell is an MCP (Model Context Protocol) server that gives AI agents isolated Docker containers to work in. Each agent gets its own persistent environment with shell access, file operations, and full audit trails.
This is a research project exploring agent autonomy: How far can we push shell-based workflows? Can agents manage their own development environments and create their own tools?
Why this exists
Current AI assistants hit fundamental walls:
  • No persistent memory: Conversations reset, context is lost, agents can't build on previous work
  • Tool babysitting: Every shell command needs human approval, breaking agent flow and autonomy
  • Limited toolsets: Agents stuck with predefined tools instead of building what they need
  • No self-reflection: Can't analyze their own traces to improve or learn from past sessions
DockaShell removes these constraints to explore what emerges:
  • Self-evolving agents: Build and refine their own tools, scripts, and workflows
  • Continuous memory: Maintain knowledge bases, wikis, notebooks that persist across sessions
  • Autonomous exploration: Run shell commands without constant human intervention
  • Meta-learning: Analyze previous traces to improve decision-making and tool usage
The core question: What can agents accomplish when they have real persistence and autonomy?
How it works
AI Agent (Claude/GPT/...)
↔ DockaShell (MCP Server)
└─ Docker Engine
├─ Container A (Project 1)
│ └─ Persistent Volume
├─ Container B (Project 2)
│ └─ Persistent Volume
└─ Container C (Project 3)
└─ Persistent Volume

Each AI agent gets its own isolated Docker container with persistent storage. Instead of dozens of custom tools, agents use standard shell commands (bash, git, npm, etc.) and build their own workflows.
Key principles:
  • Shell > specialized tools: Agents already "speak" POSIX, so let them use real commands
  • Container isolation: Full autonomy inside, zero risk to your host system
  • Persistent workspace: Files, databases, and context survive across sessions
  • Complete audit trail: Every command and file change is logged for analysis
→ See detailed architecture and security model
Quick Start
# Install
npm install -g dockashell
# Setup
dockashell build
dockashell create my-project
dockashell start my-project
Add to your MCP client configuration:
{
"mcpServers": {
"dockashell": {
"command": "dockashell",
"args": ["serve"]
}
}
}
Requirements: Node.js 20+, Docker running
Example workflows
Data analysis: Agent spins up Python environment, processes CSV files, generates insights
Web development: Agent builds React app, installs dependencies, runs dev server with live preview
Research assistant: Agent tracks information across sessions, maintains SQLite databases, remembers context
Documentation
Current state
This is active research, not production software. The core functionality works well for experimentation, but expect changes as I explore what agents can do with persistent shell environments.
Contributions and feedback welcome.
License
Apache License 2.0
About
DockaShell is an MCP server that gives AI agents isolated Docker containers to work in. MCP tools for shell access, file operations, and full audit trail.
Topics
agentcoding-agentdockermcpmodel-context-protocolvibe-coding
Resources
Readme
Apache-2.0 license
Activity
Stars
30 stars
Watchers
2 watching
Forks
7 forks
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
DockaShell
DockaShell is an MCP (Model Context Protocol) server that gives AI agents isolated Docker containers to work in. Each agent gets its own persistent environment with shell access, file operations, and full audit trails.
This is a research project exploring agent autonomy: How far can we push shell-based workflows? Can agents manage their own development environments and create their own tools?
Why this exists
Current AI assistants hit fundamental walls:
  • No persistent memory: Conversations reset, context is lost, agents can't build on previous work
  • Tool babysitting: Every shell command needs human approval, breaking agent flow and autonomy
  • Limited toolsets: Agents stuck with predefined tools instead of building what they need
  • No self-reflection: Can't analyze their own traces to improve or learn from past sessions
DockaShell removes these constraints to explore what emerges:
  • Self-evolving agents: Build and refine their own tools, scripts, and workflows
  • Continuous memory: Maintain knowledge bases, wikis, notebooks that persist across sessions
  • Autonomous exploration: Run shell commands without constant human intervention
  • Meta-learning: Analyze previous traces to improve decision-making and tool usage
The core question: What can agents accomplish when they have real persistence and autonomy?
How it works
AI Agent (Claude/GPT/...)
↔ DockaShell (MCP Server)
└─ Docker Engine
├─ Container A (Project 1)
│ └─ Persistent Volume
├─ Container B (Project 2)
│ └─ Persistent Volume
└─ Container C (Project 3)
└─ Persistent Volume

Each AI agent gets its own isolated Docker container with persistent storage. Instead of dozens of custom tools, agents use standard shell commands (bash, git, npm, etc.) and build their own workflows.
Key principles:
  • Shell > specialized tools: Agents already "speak" POSIX, so let them use real commands
  • Container isolation: Full autonomy inside, zero risk to your host system
  • Persistent workspace: Files, databases, and context survive across sessions
  • Complete audit trail: Every command and file change is logged for analysis
→ See detailed architecture and security model
Quick Start
# Install
npm install -g dockashell
# Setup
dockashell build
dockashell create my-project
dockashell start my-project
Add to your MCP client configuration:
{
"mcpServers": {
"dockashell": {
"command": "dockashell",
"args": ["serve"]
}
}
}
Requirements: Node.js 20+, Docker running
Example workflows
Data analysis: Agent spins up Python environment, processes CSV files, generates insights
Web development: Agent builds React app, installs dependencies, runs dev server with live preview
Research assistant: Agent tracks information across sessions, maintains SQLite databases, remembers context
Documentation
Current state
This is active research, not production software. The core functionality works well for experimentation, but expect changes as I explore what agents can do with persistent shell environments.
Contributions and feedback welcome.
License
Apache License 2.0
About
DockaShell is an MCP server that gives AI agents isolated Docker containers to work in. MCP tools for shell access, file operations, and full audit trail.
Topics
agentcoding-agentdockermcpmodel-context-protocolvibe-coding
Resources
Readme
Apache-2.0 license
Activity
Stars
30 stars
Watchers
2 watching
Forks
7 forks
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
DockaShell
DockaShell is an MCP (Model Context Protocol) server that gives AI agents isolated Docker containers to work in. Each agent gets its own persistent environment with shell access, file operations, and full audit trails.
This is a research project exploring agent autonomy: How far can we push shell-based workflows? Can agents manage their own development environments and create their own tools?
Why this exists
Current AI assistants hit fundamental walls:
  • No persistent memory: Conversations reset, context is lost, agents can't build on previous work
  • Tool babysitting: Every shell command needs human approval, breaking agent flow and autonomy
  • Limited toolsets: Agents stuck with predefined tools instead of building what they need
  • No self-reflection: Can't analyze their own traces to improve or learn from past sessions
DockaShell removes these constraints to explore what emerges:
  • Self-evolving agents: Build and refine their own tools, scripts, and workflows
  • Continuous memory: Maintain knowledge bases, wikis, notebooks that persist across sessions
  • Autonomous exploration: Run shell commands without constant human intervention
  • Meta-learning: Analyze previous traces to improve decision-making and tool usage
The core question: What can agents accomplish when they have real persistence and autonomy?
How it works
AI Agent (Claude/GPT/...)
↔ DockaShell (MCP Server)
└─ Docker Engine
├─ Container A (Project 1)
│ └─ Persistent Volume
├─ Container B (Project 2)
│ └─ Persistent Volume
└─ Container C (Project 3)
└─ Persistent Volume

Each AI agent gets its own isolated Docker container with persistent storage. Instead of dozens of custom tools, agents use standard shell commands (bash, git, npm, etc.) and build their own workflows.
Key principles:
  • Shell > specialized tools: Agents already "speak" POSIX, so let them use real commands
  • Container isolation: Full autonomy inside, zero risk to your host system
  • Persistent workspace: Files, databases, and context survive across sessions
  • Complete audit trail: Every command and file change is logged for analysis
→ See detailed architecture and security model
Quick Start
# Install
npm install -g dockashell
# Setup
dockashell build
dockashell create my-project
dockashell start my-project
Add to your MCP client configuration:
{
"mcpServers": {
"dockashell": {
"command": "dockashell",
"args": ["serve"]
}
}
}
Requirements: Node.js 20+, Docker running
Example workflows
Data analysis: Agent spins up Python environment, processes CSV files, generates insights
Web development: Agent builds React app, installs dependencies, runs dev server with live preview
Research assistant: Agent tracks information across sessions, maintains SQLite databases, remembers context
Documentation
Current state
This is active research, not production software. The core functionality works well for experimentation, but expect changes as I explore what agents can do with persistent shell environments.
Contributions and feedback welcome.
License
Apache License 2.0
About
DockaShell is an MCP server that gives AI agents isolated Docker containers to work in. MCP tools for shell access, file operations, and full audit trail.
Topics
agentcoding-agentdockermcpmodel-context-protocolvibe-coding
Resources
Readme
Apache-2.0 license
Activity
Stars
30 stars
Watchers
2 watching
Forks
7 forks
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
DockaShell
DockaShell is an MCP (Model Context Protocol) server that gives AI agents isolated Docker containers to work in. Each agent gets its own persistent environment with shell access, file operations, and full audit trails.
This is a research project exploring agent autonomy: How far can we push shell-based workflows? Can agents manage their own development environments and create their own tools?
Why this exists
Current AI assistants hit fundamental walls:
  • No persistent memory: Conversations reset, context is lost, agents can't build on previous work
  • Tool babysitting: Every shell command needs human approval, breaking agent flow and autonomy
  • Limited toolsets: Agents stuck with predefined tools instead of building what they need
  • No self-reflection: Can't analyze their own traces to improve or learn from past sessions
DockaShell removes these constraints to explore what emerges:
  • Self-evolving agents: Build and refine their own tools, scripts, and workflows
  • Continuous memory: Maintain knowledge bases, wikis, notebooks that persist across sessions
  • Autonomous exploration: Run shell commands without constant human intervention
  • Meta-learning: Analyze previous traces to improve decision-making and tool usage
The core question: What can agents accomplish when they have real persistence and autonomy?
How it works
AI Agent (Claude/GPT/...)
↔ DockaShell (MCP Server)
└─ Docker Engine
├─ Container A (Project 1)
│ └─ Persistent Volume
├─ Container B (Project 2)
│ └─ Persistent Volume
└─ Container C (Project 3)
└─ Persistent Volume

Each AI agent gets its own isolated Docker container with persistent storage. Instead of dozens of custom tools, agents use standard shell commands (bash, git, npm, etc.) and build their own workflows.
Key principles:
  • Shell > specialized tools: Agents already "speak" POSIX, so let them use real commands
  • Container isolation: Full autonomy inside, zero risk to your host system
  • Persistent workspace: Files, databases, and context survive across sessions
  • Complete audit trail: Every command and file change is logged for analysis
→ See detailed architecture and security model
Quick Start
# Install
npm install -g dockashell
# Setup
dockashell build
dockashell create my-project
dockashell start my-project
Add to your MCP client configuration:
{
"mcpServers": {
"dockashell": {
"command": "dockashell",
"args": ["serve"]
}
}
}
Requirements: Node.js 20+, Docker running
Example workflows
Data analysis: Agent spins up Python environment, processes CSV files, generates insights
Web development: Agent builds React app, installs dependencies, runs dev server with live preview
Research assistant: Agent tracks information across sessions, maintains SQLite databases, remembers context
Documentation
Current state
This is active research, not production software. The core functionality works well for experimentation, but expect changes as I explore what agents can do with persistent shell environments.
Contributions and feedback welcome.
License
Apache License 2.0
About
DockaShell is an MCP server that gives AI agents isolated Docker containers to work in. MCP tools for shell access, file operations, and full audit trail.
Topics
agentcoding-agentdockermcpmodel-context-protocolvibe-coding
Resources
Readme
Apache-2.0 license
Activity
Stars
30 stars
Watchers
2 watching
Forks
7 forks
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
DockaShell
DockaShell is an MCP (Model Context Protocol) server that gives AI agents isolated Docker containers to work in. Each agent gets its own persistent environment with shell access, file operations, and full audit trails.
This is a research project exploring agent autonomy: How far can we push shell-based workflows? Can agents manage their own development environments and create their own tools?
Why this exists
Current AI assistants hit fundamental walls:
  • No persistent memory: Conversations reset, context is lost, agents can't build on previous work
  • Tool babysitting: Every shell command needs human approval, breaking agent flow and autonomy
  • Limited toolsets: Agents stuck with predefined tools instead of building what they need
  • No self-reflection: Can't analyze their own traces to improve or learn from past sessions
DockaShell removes these constraints to explore what emerges:
  • Self-evolving agents: Build and refine their own tools, scripts, and workflows
  • Continuous memory: Maintain knowledge bases, wikis, notebooks that persist across sessions
  • Autonomous exploration: Run shell commands without constant human intervention
  • Meta-learning: Analyze previous traces to improve decision-making and tool usage
The core question: What can agents accomplish when they have real persistence and autonomy?
How it works
AI Agent (Claude/GPT/...)
↔ DockaShell (MCP Server)
└─ Docker Engine
├─ Container A (Project 1)
│ └─ Persistent Volume
├─ Container B (Project 2)
│ └─ Persistent Volume
└─ Container C (Project 3)
└─ Persistent Volume

Each AI agent gets its own isolated Docker container with persistent storage. Instead of dozens of custom tools, agents use standard shell commands (bash, git, npm, etc.) and build their own workflows.
Key principles:
  • Shell > specialized tools: Agents already "speak" POSIX, so let them use real commands
  • Container isolation: Full autonomy inside, zero risk to your host system
  • Persistent workspace: Files, databases, and context survive across sessions
  • Complete audit trail: Every command and file change is logged for analysis
→ See detailed architecture and security model
Quick Start
# Install
npm install -g dockashell
# Setup
dockashell build
dockashell create my-project
dockashell start my-project
Add to your MCP client configuration:
{
"mcpServers": {
"dockashell": {
"command": "dockashell",
"args": ["serve"]
}
}
}
Requirements: Node.js 20+, Docker running
Example workflows
Data analysis: Agent spins up Python environment, processes CSV files, generates insights
Web development: Agent builds React app, installs dependencies, runs dev server with live preview
Research assistant: Agent tracks information across sessions, maintains SQLite databases, remembers context
Documentation
Current state
This is active research, not production software. The core functionality works well for experimentation, but expect changes as I explore what agents can do with persistent shell environments.
Contributions and feedback welcome.
License
Apache License 2.0
About
DockaShell is an MCP server that gives AI agents isolated Docker containers to work in. MCP tools for shell access, file operations, and full audit trail.
Topics
agentcoding-agentdockermcpmodel-context-protocolvibe-coding
Resources
Readme
Apache-2.0 license
Activity
Stars
30 stars
Watchers
2 watching
Forks
7 forks
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
DockaShell
DockaShell is an MCP (Model Context Protocol) server that gives AI agents isolated Docker containers to work in. Each agent gets its own persistent environment with shell access, file operations, and full audit trails.
This is a research project exploring agent autonomy: How far can we push shell-based workflows? Can agents manage their own development environments and create their own tools?
Why this exists
Current AI assistants hit fundamental walls:
  • No persistent memory: Conversations reset, context is lost, agents can't build on previous work
  • Tool babysitting: Every shell command needs human approval, breaking agent flow and autonomy
  • Limited toolsets: Agents stuck with predefined tools instead of building what they need
  • No self-reflection: Can't analyze their own traces to improve or learn from past sessions
DockaShell removes these constraints to explore what emerges:
  • Self-evolving agents: Build and refine their own tools, scripts, and workflows
  • Continuous memory: Maintain knowledge bases, wikis, notebooks that persist across sessions
  • Autonomous exploration: Run shell commands without constant human intervention
  • Meta-learning: Analyze previous traces to improve decision-making and tool usage
The core question: What can agents accomplish when they have real persistence and autonomy?
How it works
AI Agent (Claude/GPT/...)
↔ DockaShell (MCP Server)
└─ Docker Engine
├─ Container A (Project 1)
│ └─ Persistent Volume
├─ Container B (Project 2)
│ └─ Persistent Volume
└─ Container C (Project 3)
└─ Persistent Volume

Each AI agent gets its own isolated Docker container with persistent storage. Instead of dozens of custom tools, agents use standard shell commands (bash, git, npm, etc.) and build their own workflows.
Key principles:
  • Shell > specialized tools: Agents already "speak" POSIX, so let them use real commands
  • Container isolation: Full autonomy inside, zero risk to your host system
  • Persistent workspace: Files, databases, and context survive across sessions
  • Complete audit trail: Every command and file change is logged for analysis
→ See detailed architecture and security model
Quick Start
# Install
npm install -g dockashell
# Setup
dockashell build
dockashell create my-project
dockashell start my-project
Add to your MCP client configuration:
{
"mcpServers": {
"dockashell": {
"command": "dockashell",
"args": ["serve"]
}
}
}
Requirements: Node.js 20+, Docker running
Example workflows
Data analysis: Agent spins up Python environment, processes CSV files, generates insights
Web development: Agent builds React app, installs dependencies, runs dev server with live preview
Research assistant: Agent tracks information across sessions, maintains SQLite databases, remembers context
Documentation
Current state
This is active research, not production software. The core functionality works well for experimentation, but expect changes as I explore what agents can do with persistent shell environments.
Contributions and feedback welcome.
License
Apache License 2.0
About
DockaShell is an MCP server that gives AI agents isolated Docker containers to work in. MCP tools for shell access, file operations, and full audit trail.
Topics
agentcoding-agentdockermcpmodel-context-protocolvibe-coding
Resources
Readme
Apache-2.0 license
Activity
Stars
30 stars
Watchers
2 watching
Forks
7 forks
Report repository
Releases
Used by
Contributors
Languages