Skip to main content

​
What It Does

Monk understands your entire system - every service, container, database, API - and brings monitoring and debugging capabilities directly into your IDE. No setting up log aggregation, no SSH into servers, no jumping between dashboards. Ask Monk to show logs, explain resource usage, open a shell, or troubleshoot an issue - all from chat in your IDE. When you report a problem, Monk autonomously analyzes logs, metrics, and workload state to diagnose (and potentially fix) the cause.

​
How It Works

​
System Understanding

Monk maintains a complete understanding of your running system: What Monk knows:
  • Every service and its current state (running, stopped, restarting)
  • Every container and what it’s doing
  • Every database connection and query load
  • Every API integration and its status
  • Resource usage for each component (CPU, memory, disk, network)
  • Relationships between all components
Ask Monk about your system: 
You: What's running right now?

​
Shell Access to Containers

Need to inspect a container? Get instant shell access: How to access: 
You: Give me shell access to the API server
No SSH required:
  • Direct access to any container
  • No SSH keys to manage
  • No bastion hosts needed
  • Works across all clouds

​
Live Log Streaming

View logs from any service in real-time: How to view logs: 
You: Show me logs from the API server
Log capabilities:
  • Live streaming from any service
  • Historical logs available
  • Filter by time range, severity, or keywords
  • Logs from multiple services simultaneously
  • All displayed in your IDE

​
Log Analysis & Insights

Don’t want to read logs manually? Ask Monk to analyze them: How to analyze: 
You: Check the API server logs for errors
Monk doesn’t just show you logs - it interprets them, finds patterns, and suggests fixes.

​
Resource Usage & Metrics

Track and understand resource consumption: How to check metrics: 
You: What's the resource usage?
Metrics tracked:
  • CPU, memory, disk, network for every service
  • Application-specific metrics (queue depth, connection pools, cache hit rates)
  • Database performance (query times, connection counts, slow queries)
  • Integration status (API response times, webhook deliveries)

​
Autonomous Troubleshooting

When something goes wrong, tell Monk about it: How Monk troubleshoots: 
You: Users are reporting slow page loads
What Monk does autonomously:
  1. Reads logs across all services
  2. Checks metrics and resource usage
  3. Examines workload state (containers, processes, connections)
  4. Correlates data to find root cause
  5. Suggests (and can apply) fixes
This is fundamentally different from you manually checking logs and metrics - Monk has complete system context and can investigate across all components simultaneously.

​
Watcher - 24/7 Autonomous Monitoring

Set up Watcher to monitor your cluster continuously and get alerted when issues arise: How to set up: 
You: Set up watcher
Monk configures autonomous monitoring and asks for a Slack webhook URL to send alerts. What Watcher monitors:
  • Service health and crashes
  • CPU, memory, and disk usage across all nodes
  • Container restart loops and liveness failures
  • Resource pressure and capacity issues
How it works:
  1. Continuous monitoring - Watcher watches your cluster 24/7
  2. AI diagnosis - When issues detected, AI analyzes patterns and context
  3. Slack alerts - Sends detailed notifications with diagnosis and recommendations
  4. Recovery tracking - Notifies when issues resolve
Example Slack alert: 
⚠️ AI Assessment

Sustained high CPU usage on api-server is driving node 
CPU to ~80%+, with repeated warnings but no crashes yet.

Recommendation:
Confirm this is a true capacity issue rather than a 
transient spike by continuing to monitor CPU usage. 
If sustained, increase CPU resources or scale horizontally.

Target: api-server
Severity: warning
When the issue resolves, Watcher sends a recovery notification: 
✅ AI Assessment

Recovery: CPU usage has normalized to ~78%, with workloads 
running normally and no new errors.

Recommendation:
Keep current configuration but continue to observe.
→ See Watcher Setup Guide for detailed instructions

​
Coming Soon

Autonomous Auto-Fixes COMING SOON Future Watcher capabilities will include automatic remediation:
  • Automatic restart of crashed services
  • Auto-scaling resources when sustained pressure detected
  • Applying known fixes without human intervention
  • Smart rollback on failed deployments
Currently, Watcher detects and diagnoses issues with AI-powered analysis - future versions will also fix them autonomously.

​
Observability Tools Integration

Advanced Observability Tools COMING SOON For advanced observability needs, Monk will integrate with popular tools: Planned integrations:
  • Datadog
  • New Relic
  • Grafana Cloud
  • Honeycomb
  • Sentry (error tracking)
  • Prometheus + Grafana
  • ELK Stack (Elasticsearch, Logstash, Kibana)
  • TIG Stack (Telegraf, InfluxDB, Grafana)

​
What Makes This Different

Traditional monitoring requires:
  • Setting up log aggregation (ELK, Splunk, Datadog)
  • Configuring metric collection (Prometheus, Grafana)
  • Creating dashboards and alerts
  • SSH access for container inspection
  • Manually correlating logs and metrics
  • Jumping between multiple tools and dashboards
  • Learning query languages (PromQL, LogQL, etc.)
With Monk: Ask questions in natural language. Monk analyzes logs, metrics, and system state autonomously from your IDE.

​
Key Capabilities

  • Complete system understanding - Knows every service, container, database, API
  • Watcher - 24/7 monitoring - AI-powered autonomous monitoring with Slack alerts
  • Shell access - Direct access to any container from IDE
  • Live log streaming - Real-time logs from any service
  • Log analysis - Monk interprets logs and finds patterns
  • Resource metrics - Track CPU, memory, disk, network for all services
  • Application metrics - Queue depth, cache hit rates, query times, etc.
  • Autonomous troubleshooting - Report issue, Monk investigates and suggests fixes
  • Proactive alerts - Watcher detects issues before they impact users
  • IDE-native - All capabilities accessible from your editor
  • No setup required - Works automatically for all deployments (Watcher optional)