Skip to main content

​
What It Does

Monk’s package ecosystem gives you hundreds of pre-built packages for databases, services, APIs, and infrastructure. The orchestrator uses them to deploy resources. Monk agents use them to understand and manage everything about those resources.

​
How It Works

​
What Packages Contain

Monk packages are comprehensive definitions. They carry everything needed to deploy and manage a service. Deployable workloads:
  • Container-based services (databases, web servers, message queues, etc.)
  • Configuration for running the service
  • Health checks and lifecycle management
Infrastructure definitions:
  • Cloud resource requirements (VMs, storage, networking)
  • Infrastructure blueprints for optimal deployment
  • Multi-cloud compatibility specifications
Custom resource definitions:
  • Interfaces for managing virtually any resource
  • Integration points for third-party services
  • Lifecycle hooks and operational patterns
Extensions for Monk agents:
  • Service-specific behaviors and actions
  • Monitoring and troubleshooting capabilities
  • Cost estimation interfaces

​
Composable by Design

Packages compose other packages. That’s how you build systems without reinventing anything. A web application package might compose a PostgreSQL database package, a Redis cache package, and an Nginx web server package. Each sub-package brings its own capabilities and management logic. The composed system works as a unified whole. You don’t copy-paste. You compose.

​
Extensible Without Duplication

Want a custom PostgreSQL configuration? Override the base package. Only define what’s different. Inherit everything else — container runtime setup, health checks, the works. Less repeated code. More succinct definitions. Easier to maintain. 
# Override just what you need:
namespace: my-app

postgresql:
  inherits: monk-postgresql # Base PostgreSQL package
  variables:
    max-connections: 200
    shared-buffers: "2GB"

​
Programmable with Scripting

Packages can contain arbitrary scripting for complex behaviors:
  • ArrowScript — Monk’s declarative scripting language for defining service behaviors, health checks, and operational patterns inside packages.
  • TypeScript framework — For full customization and complex logic
  • Custom operation patterns — Entirely custom workflows and actions
Use these for database backup automation, custom health checks, complex deployment orchestration, or service-specific management operations.

​
Your Code Becomes Packages

When Monk performs code analysis on your application:
  1. Monk packages up your services — each component becomes a package definition
  2. It composes them with existing packages — your services combined with databases, caches, etc.
  3. You review the resulting definition — see the full packaged system
Your application gets treated the same way as pre-built packages. Same capabilities for deployment, scaling, and management.

​
Content-Addressed and Immutable

Security is built into the package system.
  • Content-addressed — packages identified by cryptographic hash of their contents
  • Immutable — once published, a package can’t be changed
  • Guarded against supply chain attacks — tampering is prevented by design
Packages are currently permissioned and vetted by the Monk team. Quality standards are enforced before publication, and community contributions are reviewed and tested.

​
The Ecosystem

Hundreds of packages. Databases like PostgreSQL, MySQL, MongoDB, Redis. Message queues like Kafka and RabbitMQ. Monitoring stacks, DevOps tools, CMS platforms, AI/ML runtimes, and more. See Integrations for the full list.

​
Open Source Contributions

Many Monk packages are open source on GitHub at monk-io. You can review package definitions, submit improvements, contribute new packages, or learn from existing implementations. Popular repositories include monk-metabase, monk-prometheus-grafana, monk-ollama, and 100+ more.
Private packages for teams — team-specific repositories, version control, access control — are on the roadmap. Vote on what to prioritize.

Containerization & Orchestration

How the orchestrator uses packages to deploy your stack.

Code Analysis

How Monk turns your code into packages.