> ## Documentation Index
> Fetch the complete documentation index at: https://docs.monk.io/llms.txt
> Use this file to discover all available pages before exploring further.

# FAQ

> Frequently asked questions about Monk, its capabilities, deployment, security, and best practices.

## General Questions

### What is Monk?

Monk is an **AI DevOps agent** that takes applications from code to production autonomously. While coding assistants help you write code, Monk handles deployment — analyzing your codebase, containerizing your application, provisioning infrastructure, and deploying it to your preferred environment with minimal intervention.

### How is Monk different from other AI coding assistants?

Monk is **not** a coding assistant.

* **Coding assistants** generate or suggest code changes
* **Monk** deploys and manages your code at runtime
* Monk understands both your code *and* its runtime state
* Monk operates deployments and cloud environments autonomously

### Which languages and frameworks does Monk support?

Monk supports **all mainstream languages and frameworks** — there are no restrictions. Whether you're using Node.js, Python, Go, Rust, Java, or any other language, with any framework (React, Vue, Django, FastAPI, Spring Boot, etc.), Monk can deploy it.

### Can I use Monk with my preferred IDE?

Yes. Monk supports:

* **VS Code**
* **Cursor**
* **Windsurf**

Install the Monk extension and you're ready to go.

## Deployment & Capabilities

### What applications can I deploy with Monk?

Monk handles any application architecture:

* **Web applications** — React + Node.js + PostgreSQL, Next.js, Vue, Angular, etc.
* **APIs and microservices** — REST, GraphQL, gRPC endpoints
* **AI/ML workloads** — LLM serving, GPU-accelerated inference
* **Background workers** — job queues, scheduled tasks, event processors
* **Multi-service architectures** — Any combination of services, databases, caches, queues
* **Monoliths or distributed systems** — Monk adapts to your architecture

### Does Monk lock me into a specific cloud provider?

No. Monk is **multi-cloud native** and BYOI (Bring Your Own Infrastructure):

* Deploy to **AWS, GCP, Azure, DigitalOcean, Hetzner, Netlify, Vercel**, and more
* Switch between providers at any time
* Your infrastructure is yours — Monk orchestrates, you own everything
* Use credentials from your own cloud accounts

### How does Monk know what my application needs?

Monk uses **autonomous code analysis**:

1. Analyzes your source code to understand the tech stack
2. Detects services you need (databases, caches, queues, etc.)
3. Identifies dependencies and configuration requirements
4. Asks clarifying questions if needed
5. Automatically provisions only what's required

For example, Monk can detect that you need PostgreSQL, Redis, and a job queue — then deploy all of them correctly configured and connected.

### Can I use Monk with existing applications?

Yes. Monk works with:

* Brand new applications
* Existing production applications
* Applications you want to migrate from other platforms

### Can Monk deploy complex applications?

Yes. Monk can deploy **multiple services simultaneously** as long as they're all in your workspace:

* **Monorepos** — Deploy all services from a single repository
* **Multi-directory workspaces** — Open a directory containing multiple services
* **Mixed languages** — No problem. Deploy Python + Node.js + Go services together
* **Auto-detection** — Monk analyzes each service and deploys them with proper configuration and networking

For example, deploy a React frontend, Node.js API, Python background worker, and PostgreSQL database all at once — Monk handles the connections, environment variables, and deployment coordination.

### Can Monk help me migrate between cloud providers?

Yes. Use the **workload migration** feature to move your entire application stack to a different cloud provider with a single command. Monk handles:

* Creating resources in the new cloud
* Transferring workloads
* Updating DNS and routing
* Intelligent cost optimization (keeping expensive workloads in their original cloud if more cost-effective)

Read more about [Workload Migration](/features/workload-migration) and how Monk handles it.

### Do I need to write Dockerfiles or Kubernetes configs?

No. Monk handles all of this **autonomously**:

* **Zero Dockerfiles** — Monk containerizes your app
* **Zero Kubernetes manifests** — Monk orchestrates autonomously
* **Zero infrastructure-as-code** — Monk generates configs autonomously
* **Zero manual DevOps** — Just describe what you want in chat

### Does Monk use Kubernetes or Terraform under the hood?

**No.** Monk uses its own **distributed orchestrator** that manages containers and infrastructure natively.

**Why this matters:**

* **No Kubernetes complexity** — Skip the steep learning curve of K8s, YAML manifests, and Helm charts
* **No Terraform quirks** — Avoid state management issues and infrastructure drift
* **Eliminates leaky abstractions** — Direct control without abstraction layers that expose underlying complexity
* **Improved consistency** — One system managing everything from containers to cloud resources
* **Better safety** — Built-in agentic safety without configuration pitfalls
* **Resource efficient** — No Kubernetes control plane overhead

**What Monk's orchestrator does:**

* Native container management across any cloud
* Real-time resource tracking and dependency graphs
* Automatic networking and service mesh
* Multi-cloud orchestration from a unified control plane
* Cost tracking for every resource

Read more about [Containerization & Orchestration](/features/containerization) and how Monk's orchestrator works.

## Security & Privacy

### How does Monk handle security and credentials?

Monk takes security seriously:

* **Credentials stay on your machine** — Never sent to Monk servers
* **Code encryption** — Your code is sent to Azure/OpenAI LLMs piece-by-piece in encrypted form
* **No training** — We don't train models on your code
* **Agentic safety** — Built-in safeguards for autonomous operations
* **Secure storage** — Credentials stored encrypted on your side
* **Runtime security** — SSL/TLS, firewalls, IAM policies configured automatically

### Can Monk access my private code?

Monk processes your code to understand how to build and deploy it. Your code is:

* Sent to cloud LLMs in encrypted form
* Analyzed and discarded after processing
* Never stored on Monk servers
* Never used for model training

### Does Monk set up security features automatically?

Yes. Monk configures:

* **SSL/TLS certificates** — HTTPS by default
* **Firewalls** — Network isolation and security groups
* **Secret management** — Environment variables and secrets handled securely
* **Authentication** — API authentication and access controls

## Workflow & Operations

### What happens if something goes wrong during deployment?

Monk provides:

* **Clear error messages** — Understand exactly what failed
* **Autonomous troubleshooting** — Ask Monk to debug and fix issues
* **Rollback capability** — Revert to previous deployments
* **Logs and debugging** — Access logs, metrics, and traces directly from your IDE

### Can I customize or override Monk's deployment decisions?

Yes. You can:

* Specify which cloud provider to use
* Choose between managed services (e.g., AWS RDS) or self-hosted (e.g., PostgreSQL container)
* Configure resource sizing (CPU, memory, storage)
* Set environment variables and secrets
* Customize networking, domains, and DNS

### Does Monk support multiple environments (dev, staging, production)?

Not at the moment. You can create multiple Monk clusters for different environments manually.

Full support for multiple environments is coming soon with team features. See [Project Organization](/features/project-organization) for more details.

### How does Monk handle updates and maintenance?

Monk can:

* **Push code updates** — Deploy new versions with the usual `deploy` prompt or by pushing to your repository if you've [set up CI/CD](/features/build-and-cicd)
* **Update services** — Update your application or dependencies
* **Scale resources** — Adjust CPU, memory, or replica counts

### Can Monk help me monitor and debug my application?

Yes. From your IDE, you can:

* **View logs** — Real-time application and system logs
* **Track metrics** — CPU, memory, network, custom metrics
* **Monitor costs** — Real-time cost tracking and breakdowns
* **Debug issues** — Analyze problems and ask Monk to troubleshoot
* **Check health** — Service status, uptime, performance metrics

## Comparison & Migration

### How does Monk compare to Kubernetes?

|                     | Monk                       | Kubernetes                         |
| ------------------- | -------------------------- | ---------------------------------- |
| **Learning curve**  | Chat-based, no CLI         | Steep, complex YAML                |
| **Configuration**   | Autonomous                 | Manual manifests                   |
| **Multi-cloud**     | Native support             | Possible but complex               |
| **Deployment**      | One command via chat       | Manual kubectl commands            |
| **Cost management** | Built-in tracking          | Manual or third-party              |
| **Architecture**    | Native orchestrator        | K8s control plane + operators      |
| **Best for**        | Teams wanting to ship fast | Infrastructure-first organizations |

**Monk doesn't use Kubernetes** — it has its own distributed orchestrator that eliminates K8s complexity while providing the same container orchestration capabilities. This means no YAML files, no Helm charts, no kubectl, and no K8s learning curve.

### How does Monk compare to Docker Compose?

Docker Compose is for **local development**. Monk is for **production deployment**:

* **Docker Compose** — Local multi-container environments
* **Monk** — Production deployments across clouds with scaling, monitoring, CI/CD, and more

You can use Docker Compose locally, then deploy to production with Monk. Monk will read your existing `docker-compose.yml` and create a production-ready cloud deployment — no Kubernetes required.

### Can I migrate from another deployment platform (Heroku, Netlify, AWS Amplify)?

Yes. Monk supports deploying any application to any cloud. Monk will migrate your existing application to the new environment by looking at its source code and configuring deployment in the new environment from scratch.

If you're migrating from:

* **Heroku** — Use Monk for full-stack apps with more control
* **Netlify/Vercel** — Use Monk for full-stack deployments beyond static sites
* **AWS Amplify** — Use Monk to migrate your application to a different cloud provider
* **Kubernetes** — Use Monk to eliminate complexity and gain multi-cloud flexibility
* **Railway** — Use Monk to gain architectural flexibility and integrate with other services

## Usage & Learning

### What's the learning curve for using Monk effectively?

Monk is designed to be **intuitive**:

* **No CLI to memorize** — Just describe what you want in chat
* **Natural language interface** — "Deploy my app" works
* **Progressive learning** — Start simple, learn advanced features as needed
* **Autonomous guidance** — Monk explains what it's doing and asks clarifying questions

Start with the [Getting Started](/getting-started/what-is-monk) guide and [Prompting Cookbook](/prompting/how-prompting-works) for task-focused examples.

### How do I get help while using Monk?

Multiple ways to get help:

1. **Ask Monk directly** — Use the chat window (Cmd+Shift+M)
2. **Report bugs/features** — Built-in reporting through the IDE
3. **Documentation** — [Full docs](/features) and [Prompting Cookbook](/prompting/how-prompting-works)
4. **Community** — [Community forum](https://roadmap.monk.io/) for discussions and feedback
5. **Direct support** — Email [hi@monk.io](mailto:hi@monk.io) for account and billing issues

See the complete [Getting Help & Support](/getting-help) guide for all support channels, response times, and best practices.

### How often should I update Monk?

Monk updates frequently with new features and improvements. Check the [Changelog](/changelog-updates) for what's new. Updates are automatic when you restart your IDE.

## Pricing & Accounts

### Is Monk free to use?

Yes, with a **7-day free trial** that includes 50 credits. No credit card required.

### How much does Monk cost?

For current pricing, visit **[Monk Pricing](https://monk.io/pricing)**.

## Team Features

### Does Monk support team collaboration?

Currently, Monk is optimized for individual developers. Team features are under development. See [Project Organization](/features/project-organization) for more details.

Team and Enterprise features are **coming soon**:

* Shared workspaces
* Collaborative debugging
* Multi-project management
* RBAC and SSO
* Custom knowledge bases

Watch the [Changelog](/changelog-updates) for updates.

## Troubleshooting

### Monk can't connect to my cloud provider

Check that:

1. Your credentials are valid
2. Your account has sufficient permissions
3. You've authorized Monk to access your cloud account
4. Ask Monk directly — it can guide you through troubleshooting

### My deployment is slow

Check if your project contains large files or complex dependencies that are slowing down the deployment.

Ask Monk to analyze your Dockerfiles and optimize the build process.

### Monk isn't recognizing my application structure

Be more specific:

* Describe your tech stack explicitly in `README.md` file - Monk will look there for the information
* Mention the services you need
* Briefly describe project directory structure
* Provide context about your database choices
* Ask Monk to analyze your project structure

### How do I report bugs or request features?

**Through the IDE:** Use the built-in bug/feature reporting button in the Monk chat window.

**Online:** Visit the [Community Forum](https://roadmap.monk.io/) to submit bugs, request features, and vote on proposals.

See [Getting Help & Support](/getting-help) for detailed instructions with screenshots.

## Get Started

Ready to deploy? Head to [Getting Started](/getting-started/what-is-monk) or jump into the [Prompting Cookbook](/prompting/how-prompting-works) for common tasks.