AI Agent micro-service Framework.

JavaScript-native AI agent orchestration via containerization. Deploy anywhere, scale infinitely.

Click to copy

$npm install -g dank-ai

Quick Start

Get started in 3 steps

From installation to running your first agent in under 5 minutes.

Install Dank

npm install -g dank-ai

Install Dank globally with a single command. Auto-detects and installs Docker if needed.

Initialize Project

dank init my-agent-project

Create your agent configuration and project structure with built-in templates.

Run Agents

dank run

Deploy and manage your agents with Docker orchestration and real-time monitoring.

Why Dank

Built for the modern developer

JavaScript-powered, Docker-native, and open-source from day one.

Multi-Agent Orchestration

Deploy and manage multiple AI agents as containerized services

Multiple AI agents running as containers

JavaScript Native

Built on the world's most popular programming language. No Python dependencies, no complex setup—just familiar JavaScript that every developer knows.

98% of developers use JavaScript

Universal Deployment

Docker containers work everywhere—AWS, GCP, Azure, Kubernetes, or your own servers. Deploy to any stack, any cloud, any infrastructure.

100% infrastructure agnostic

Open Source & Extensible

MIT licensed and community-driven. Add custom LLM providers, extend functionality, or contribute back to the ecosystem.

MIT licensed • Community driven

CI/CD Made Simple

Docker-native architecture means your agents build, test, and deploy like any other containerized application.

Production-Ready Images

Dank automatically builds optimized Docker images of your agents with all dependencies included. No more "works on my machine" issues.

dank build --push registry.com/my-agent:v1.0

Universal Compatibility

Deploy to any container orchestration platform—Kubernetes, Docker Swarm, AWS ECS, or your own infrastructure. Same agent, anywhere.

Kubernetes•Docker Swarm•AWS ECS•Azure ACI

Configuration

Define agents in seconds

Simple JavaScript configuration with powerful Docker orchestration under the hood.

dank.config.js

const { createAgent } = require('dank-ai');

module.exports = {

agents: [

createAgent('customer-service')

.setLLM('openai', {

model: 'gpt-4',

temperature: 0.7

})

.setResources({

memory: '1g',

cpu: 2

})

.setPrompt(`You are a helpful customer service agent...`)

.addHandler('output', console.log)

]

};

Simple Configuration

Define your AI agents with clean, readable JavaScript. No complex YAML files or obscure configuration syntax.

Choose Your LLM

OpenAI, Anthropic, Cohere, Ollama—or add your own custom provider with a few lines of code.

Configure Resources

Set memory, CPU, and timeout limits. Dank handles the Docker container configuration automatically.

Add Event Handlers

Define prompts, add event handlers, and customize behavior with familiar JavaScript patterns.

CLI Commands

Powerful command-line interface

Deploy, build, and manage your agents with simple commands.

Run Agents

dank run

Dank automatically builds Docker images, manages containers, and provides real-time monitoring with zero configuration.

Build Images

dank build

Create optimized Docker images with all dependencies included. Perfect for production deployment and CI/CD pipelines.

Push to Registry

dank build --push

Build and push your agent images to any Docker registry. Integrates seamlessly with GitHub Actions and GitLab CI.

Event-Driven Architecture

Event Triggered Architecture

Loose coupling, flexible development, and patterns every developer already knows. Much more flexible than workflows.

agent-handlers.js

const agent = createAgent('smart-assistant');

// Preprocess requests before LLM

agent.addHandler('request_input', async (context) => {

const { input, userId } = context;

// Fetch user context from database

const userHistory = await getUserHistory(userId);

const ragContext = await searchRAG(input);

// Enhance context before LLM

context.enhancedInput = {

original: input,

history: userHistory,

ragContext: ragContext

};

});

// Process LLM responses

agent.addHandler('request_output', async (response) => {

// Save conversation to database

await saveConversation(response);

// Update user preferences

await updateUserPreferences(response);

});

// Handle errors gracefully

agent.addHandler('request_error', async (error) => {

await logError(error);

await notifyAdmin(error);

});

Stateless runtime wrapped with stateful event handlers

Intercept requests before they hit the LLM to add database calls, RAG systems, and user context. Make your agents stateful and context-aware with familiar JavaScript patterns.

Familiar Patterns

Event listeners, async/await, and standard JavaScript patterns. No new syntax to learn—just the patterns you already use.

Loose Coupling

Handlers are independent and composable. Add, remove, or modify logic without affecting other parts of your system.

Easy Testing

Test individual handlers in isolation. Mock events, verify outputs, and ensure reliability with standard testing practices.

Built-in Events

request_input

request_output

request_error

agent_start

agent_stop

agent_output

custom-event

any-event

Preprocess requests, enhance responses, and add stateful behavior with database calls and RAG systems.

Distributed Runtime

Each agent gets its own runtime

Deploy agents across disparate cloud services with independent scaling and resource allocation.

Independent Agent Runtimes

Each agent runs in its own isolated container

Customer Service Agent

AWS ECS

Runtime: Node.js 18 • Memory: 1GB • CPU: 2 cores

Data Processing Agent

GCP Cloud Run

Runtime: Node.js 18 • Memory: 2GB • CPU: 4 cores

Content Generation Agent

Azure Container Instances

Runtime: Node.js 18 • Memory: 512MB • CPU: 1 core

True Horizontal Scaling

Each agent is packaged as an independent Docker container that can be deployed to any cloud provider, scaled independently, and managed separately from other agents.

Independent Scaling

Scale each agent based on its specific workload. High-traffic agents get more resources while low-usage agents stay cost-effective.

Multi-Cloud Deployment

Deploy different agents to different cloud providers. Use AWS for some, GCP for others, Azure for compliance requirements.

Isolated Resources

Each agent gets its own memory, CPU, and network resources. No resource contention between agents, ensuring consistent performance.

Registry Agnostic

Commit agent runtimes to any container registry—Docker Hub, AWS ECR, GCP Artifact Registry, or Azure Container Registry.

Deploy AI agents with confidence.

Runtime independent AI Agent Framework.

Creator

Built in the shadows

Delta-Darkly

An elusive figure who emerges from the digital shadows, crafting tools that exist in the liminal space between human creativity and artificial intelligence. Delta-Darkly operates in the interstices of code and consciousness, building bridges between worlds that were never meant to meet.

Like a digital phantom, they appear only when the code compiles and the containers run. Their presence is felt in the elegant simplicity of solutions that others find impossibly complex.

Follow the trail deltadarkly@gmail.com

Community

Join the Dank Community

Connect with developers, get support, share your projects, and stay updated on the latest Dank developments.

Join Discord Server

Get Support

Get help from the community and core developers

Share Projects

Showcase your Dank-powered AI agent projects

Stay Updated

Get the latest news and feature announcements

Support

Keep Dank Open Source

Help keep Dank free and open source. Your donations support development, infrastructure, and the continued evolution of containerized AI agent orchestration.

Donation Address

0xF4E97E86c4e2a7CF60bAa3Fae78F80a4CDE86fCD

Accepts ETH and ERC-20 tokens

Works on any EVM-compatible network

Supports development and infrastructure