DEV Community: Karan Jagtiani

Skyflo: AI agent for Cloud & DevOps

Karan Jagtiani — Wed, 31 Dec 2025 15:13:44 +0000

Cloud and DevOps work is not hard because the commands are hard.

It is hard because your context is fragmented.

Terminals, dashboards, logs, CI, rollouts
Different auth models per system
Different failure modes per workflow
No shared audit trail of what happened and why

Skyflo.ai is my attempt to reduce that fragmentation.

Skyflo is an open-source AI agent for Cloud and DevOps.
It unifies Kubernetes operations and CI/CD behind a natural language interface, with approvals built in.

The important part is not “chat with prod”.

The important part is control.

What Skyflo is

Skyflo is a command center, an agent engine, and a standardized tool layer.

Command Center (UI): a chat interface that streams every step in real time
Engine: a service that runs a LangGraph workflow and turns intent into safe tool calls
MCP Server: a tool server exposing standardized integrations for Kubernetes and CI/CD

You express intent in plain English.

What executes is always a validated tool call.

What Skyflo is not

Skyflo is not “give an LLM kubectl and pray”.

If you want autonomous mutation in production without approvals, you are optimizing for demos.
You are not optimizing for reliability.

Skyflo is designed for operators who want automation without losing control.

SREs
DevOps engineers
cloud architects
platform teams
security minded operators

The safety model

Skyflo is built around a simple policy:

The agent can propose and prepare. You approve mutations.

That policy shows up in four places.

1) Human in the loop for mutations

Any WRITE operation requires explicit approval.

Examples:

apply, rollout promote or cancel
Helm upgrade or rollback
actions that stop or cancel builds

Read only workflows can run end to end.

2) Plan → Execute → Verify

This is the only loop that matters in operations.

Skyflo runs an iterative workflow:

Plan: interpret intent and perform lightweight discovery when needed
Execute: call tools, then pause for approval if the next step is a write
Verify: validate outcomes against intent, then continue or stop

3) Everything streams in real time

Operators do not trust black boxes.

Skyflo streams what it is doing as it does it:

model output
tool progress
tool results
workflow events
approvals and decisions

This is operational safety.
It is also how you debug the agent.

4) Standardized tool execution via MCP

Integration work is where most agent projects fail.

Skyflo uses MCP so tools are:

discoverable
typed
validated
documented
separable from the agent logic

The Engine does not know kubectl.
It knows tools.

Supported tools (today)

Skyflo ships with standardized tools for:

Kubernetes: discovery, get and describe, logs and exec, safe apply and diff flows
Argo Rollouts: status, pause and resume, promote and cancel, progressive delivery visibility
Helm: search, install, upgrade, rollback with dry run and diff first safety
Jenkins: jobs, builds, logs, SCM context, identity, secure auth, CSRF handling

Write operations always require approval.

What real workflows look like

These prompts map to real on call muscle memory.

Debug a production issue

Show me the last 200 lines of logs for checkout in production. If there are errors, summarize them. Then check if any rollout is in progress.

What you should see:

discovery of namespace, deployment, and pods
logs and events
rollout state inspection
a structured summary

Progressive delivery with guardrails

Canary rollout auth-backend in dev through 10/25/50/100 steps. Pause at 25% if error rate increases.

What you should see:

a rollout plan and read only checks first
an approval gate before any mutation
verification after each step

Jenkins investigation

Pull logs for the last failed build of job X. Extract the first failing stage and tell me what changed since the last green build.

What you should see:

build discovery
log retrieval
structured extraction
a concrete next step

Quick start

Install Skyflo.ai into a Kubernetes cluster:

curl -sL https://raw.githubusercontent.com/skyflo-ai/skyflo/main/deployment/install.sh -o install.sh
chmod +x install.sh
./install.sh

Skyflo supports multiple LLM providers via LiteLLM, including self hosted models.

Contributing: step into the operator’s seat

The best way to contribute to Skyflo is to first use it the way it is meant to be used.

Not by reading issues.
Not by scanning PRs.
By running it, observing it, and tracing how decisions flow through the system.

Think of this as stepping into the contributor’s shoes.

1) Run Skyflo locally and watch it work

Start by cloning the repo and running Skyflo on your own machine or cluster.

Do not rush to change anything yet.

Use it as an operator would:

issue a few realistic prompts
watch how intent becomes a plan
observe where approvals are enforced
see how tools are discovered and executed
follow the streamed events in the UI

At this stage, the goal is intuition, not contribution.
You should be able to explain what the agent is doing at each step without reading the code.

2) Trace the agentic loop end to end

Once you are comfortable with the surface, go deeper.

Add logs and traces to the engine.

Follow a single request through the entire lifecycle:

intent parsing
planning and discovery
tool selection and execution
approval gates
verification and termination

This is where most understanding is built.

You will see where state lives, how LangGraph nodes transition, and why certain steps are deliberately slow or blocked.
You will also see why “just let it run” is not acceptable in production.

3) Study closed issues and merged PRs

Before picking something new, look at what has already shipped.

Read closed issues and their corresponding PRs.

Focus on:

what problem was being solved
what safety constraints shaped the solution
how tools were extended or restricted
how streaming, approvals, and verification were preserved

This gives you a strong signal of project standards.
You will quickly see what kinds of changes are welcomed and which ones are rejected.

4) Pick a good first issue, or create one

At this point, picking an issue becomes straightforward.

There are almost always good first issues available.
If you cannot find one that matches your understanding, create one yourself.

Good issues usually come from observations like:

a workflow that feels clunky when used
a missing verification step
a tool that exposes too much power
a safety check that should exist but does not

Open the issue.
Propose the shape of the solution.
Then start implementing it.

If you follow this path once, you will not just contribute to Skyflo.

You will understand how production grade agent systems are built, debugged, and kept safe.
That experience is far more valuable than shipping another isolated feature.

Get involved

Pick an issue and start contributing. Or create a new issue and start a discussion.

GitHub: https://github.com/skyflo-ai/skyflo
Issues: https://github.com/skyflo-ai/skyflo/issues
Discord: https://discord.gg/kCFNavMund

Connect with me

I am Karan Jagtiani, founder of Skyflo.ai.
You can find me at karan.social

Drop a comment if you have a good first issue or runbook idea for Skyflo.

QuickNode: Supercharging Your Node.js, TypeScript, and PostgreSQL Projects

Karan Jagtiani — Sun, 18 Jun 2023 06:49:35 +0000

Hello, fellow developers!

Today, I'm thrilled to introduce QuickNode, an open-source starter kit for Node.js, TypeScript, and PostgreSQL projects. This comprehensive pack is designed to kickstart your backend development, setting up a robust, scalable, and secure server environment in no time.

What is QuickNode?

QuickNode is not just another starter kit; it's a complete ecosystem that provides a solid foundation for your backend projects, combining the power of Node.js, TypeScript, PostgreSQL, Express.js, Sequelize, Docker, and a host of other cutting-edge technologies.

The project's primary aim is to streamline the initial setup process, letting you focus on what truly matters: writing impactful application code.

Highlights of QuickNode

Express.js: Provides a ready-to-go HTTP server with predefined /user routes, giving your project a running start.
Sequelize ORM: Simplifies PostgreSQL database interactions, making it easier for developers to manage database operations.
Speedy Compilation: Employs SWC, the fastest TypeScript compiler available, accelerating your development process.
Docker Integration: Comes pre-configured with an alpine image for efficient, production-grade deployments.
Advanced Security: Integrates JWT and Bcrypt for encrypted user authentication and password storage, ensuring the secure handling of sensitive user data.
Comprehensive Testing: Utilizes Jest and Supertest to ensure code integrity and comprehensive test coverage.

Who can benefit from QuickNode?

Whether you're a seasoned backend developer looking to save time on project setup or a beginner diving into the world of Node.js, TypeScript, and PostgreSQL, QuickNode is built for you. By abstracting away the complex setup process, QuickNode provides a clean slate to start building your applications straight away.

How to get started?

Getting started with QuickNode is as simple as cloning the repository, installing the dependencies, and building the project. And just like that, you're ready to start developing!

Wrapping Up

QuickNode aims to be a constantly evolving project that grows with the community's needs. I welcome contributions, suggestions, and feedback to improve and expand the project. If you find QuickNode useful, please consider starring ⭐️ the repository on GitHub - your support means a lot!

Check out QuickNode on GitHub: QuickNode

Happy coding, and may QuickNode serve you well in your coding journey!

Building a GitHub Repository Cloner and Commit Crawler with Go

Karan Jagtiani — Sat, 10 Jun 2023 06:10:49 +0000

Hello everyone!

In this post, I'm excited to share a project I've been working on: a GitHub Repository Cloner and Commit Crawler. This Go application is designed to clone a user-provided list of repositories and then crawl through the commit history of each, all without utilizing GitHub APIs.

What Does It Do?

Our application has a set of specific features that make it both versatile and easy to use:

Repository Cloning: Clone multiple GitHub repositories using SSH. This is a secure and efficient way to fetch repositories for local analysis.
Commit Crawling: Traverse the commit history of each repository, providing valuable insight into past code changes.
Customization: You can specify how many days in the past you want to crawl and for which author.
Security: The app uses your personal SSH keys for secure operations.
Security: Uses your personal SSH keys for secure operations.

Why Did I Build This?

When working with open-source projects or conducting codebase analysis, you often need to examine the commit history of multiple repositories. GitHub APIs can provide this data, but there are limitations and complexity in handling API responses.

Building a tool that uses Git directly to clone repositories and crawl commit history bypasses these restrictions and offers greater flexibility.

How Does It Work?

Here's a quick rundown of the steps involved in using the application:

Installation: First, you need to clone the repository and build the project.

git clone git@github.com:KaranJagtiani/go-git-cloner.git

Setup SSH Key: Copy your SSH key that has access to the repositories you wish to crawl in the ssh_key folder.
Configuration: The config.yaml file is your control center. Here, you specify the repositories to clone, the author email, and the days you wish to crawl in the past.
Build: Build the project as a binary.

go build -o out/go-git-cloner

Execution: Run the built binary.

./out/go-git-cloner

Voila! Your specified repositories are cloned, and the commit history is crawled.

Open Source Contribution

The project is open-source and contributions are always welcome! To contribute, simply fork the project, create your feature branch, commit your changes, and open a pull request.

Wrapping Up

The GitHub Repository Cloner and Commit Crawler offers an efficient and secure method to clone and crawl GitHub repositories, providing a flexible tool for codebase analysis. I hope it helps in your development journey!

The project is open-source and I welcome any contributions, suggestions, and feedback. You can find the project here.

If you have any questions, want to connect with me, or are interested in checking out my other work, feel free to visit my website: https://karanjagtiani.com. I'm always excited to connect with fellow developers and open-source enthusiasts. Looking forward to hearing from you!

Supercharge Your Web Development with NextJS: 9 Key Advantages

Karan Jagtiani — Fri, 07 Apr 2023 15:45:43 +0000

Since Facebook (now Meta) first released React in 2013, it's been a go-to choice for building web applications. But recently, a challenger has emerged – NextJS! Developed by Vercel, NextJS is a powerful React-based framework that comes packed with awesome features to make your web applications highly scalable. Ready for nine reasons why NextJS leaves React in the dust for creating scalable web apps with exceptional user experiences, lightning-fast load times, and killer SEO features? Let's dive in!

1. SEO Magic Out of the Box

NextJS is a superhero when it comes to Search Engine Optimization (SEO). It's got features like server-side rendering (SSR) and static site generation (SSG) in its arsenal, helping your web app rank higher and score more organic traffic. Plus, NextJS makes managing the head tag, meta tags, and structured data a breeze! React does support SEO, but you'll need third-party libraries and extra configs to get the job done.

2. SSR: Your Web App's Secret Weapon

NextJS has built-in support for server-side rendering (SSR), a game-changer that lets web applications render pages on the server before sending them to the client. This slashes the initial load times and boosts SEO performance. Meanwhile, React apps by default render the HTML pages client-side, which can lead to longer load times and subpar SEO.

3. SSG: The Need for Speed

Static Site Generation (SSG) is where NextJS really shines. With SSG, your web pages are pre-rendered as static HTML files, giving you blazingly fast load times, which results in better SEO performance. React also has SSG support with 3rd party tools, but it's just not as smooth and integrated as it is in NextJS!

4. ISG: Keep Your Content Fresh

Incremental Site Generation (ISG) is a unique NextJS feature that lets you update static pages incrementally, so you don't have to rebuild your entire site. It's a game-changer for big web apps with frequently updated content, cutting down on build times and ensuring users see the latest and greatest. Sadly, React doesn't have a built-in ISG solution.

5. Auto Code Splitting for the Win

NextJS automatically breaks your app's code into smaller chunks, so only the necessary code is loaded for each page. This means faster page loads and happier users! React supports code splitting too, but you'll have to set it up manually – and who has time for that?

6. TypeScript Support: No Sweat

NextJS is all about making life easier with first-class TypeScript support. Just a minimal config, and you're ready to enjoy TypeScript's benefits like better code quality and refactoring. React supports TypeScript too, but it requires extra setup.

7. File-System Based Routing: Easy Peasy

NextJS's file-system based routing system is a breeze, automatically generating routes based on your app's file structure. With React, you'll need third-party libraries like React Router to handle routing – adding complexity to your development process.

8. Auto Performance Optimization: Just Works

NextJS auto-optimizes your web app's performance using techniques like prefetching, inlining critical CSS, and lazy loading images. This means a smoother user experience, faster loads, and less resource consumption. React has some performance optimization features, but they're not as comprehensive or automatic as NextJS.

9. Experimental Features? More Like Cutting-Edge

NextJS has a faster release cycle than React, which means experimental features often become stable sooner. That's great news for developers who want to stay ahead of the curve and keep their web apps fresh and competitive. React does release new features, but its slower release cycle can be a bit of a downer for devs who crave the latest and greatest.

Still not Convinced?

If you are still not convinced by the points mentioned above, React themselves list NextJS as the no. #1 choice for creating new React applications. Recently, the team at React replaced the notorious create-react-app with NextJS, Remix, Gatsby and Expo as options for creating a brand new React app on the Start a New React Project page!

The Verdict: NextJS Takes the Crown

There's no denying it – NextJS is the takes the crown when it comes to building scalable web applications. With its impressive arsenal of features, including built-in SSR, automatic code splitting, SSG, ISG, TypeScript support, file-system based routing, automatic performance optimization, rapid adoption of experimental features, and out-of-the-box SEO support. NextJS makes creating cutting-edge web apps a breeze. So if you're considering developing a scalable, high-performance, react-based web application, it's time to give NextJS a shot – you won't be disappointed!

If there are any points I missed that make NextJS a compelling and go-to framework to use for production applications, please do mention them in the comments.

Please don't hesitate to reach out to me directly. I'm always happy to hear from readers and help in any way I can.

Thanks again for taking you time to read this article, see you next time :)

Send Logs from Go to Logstash in the ELK Stack with Docker Setup

Karan Jagtiani — Sun, 26 Feb 2023 19:55:31 +0000

Logging is a critical component of any application, allowing developers to easily identify and troubleshoot issues that arise during runtime. However, as applications become more complex, it can be challenging to manage and analyze logs in a way that is both efficient and effective. This is where Logstash comes in. Logstash is a powerful tool that simplifies the process of collecting, processing, and storing logs in a centralized location. In this blog post, we will explore how to push logs from a Go app to Logstash using the go-logstash package.

What is Logstash?

Logstash is an open-source tool that allows developers to easily ingest, process, and store logs. It is part of the Elastic Stack (also known as ELK), which includes Elasticsearch and Kibana. Logstash provides a variety of input and output plugins that allow it to collect logs from a wide range of sources, including files, TCP/UDP sockets, and messaging systems like Kafka and RabbitMQ. Once collected, Logstash can process and enrich the logs before forwarding them to Elasticsearch for storage and analysis.

Introducing go-logstash

go-logstash is a Golang package that provides a simple interface for pushing logs to Logstash. It supports both TCP and UDP protocols and can output logs in either JSON or string format. go-logstash is easy to use and provides customizable options for configuring the Logstash connection.

Setting up Logstash

Before we can start pushing logs to Logstash, we need to set up a Logstash instance. This can be done by downloading and installing Logstash from the Elastic website or setting it up using Docker Compose.

Create a new directory, let's call it go-logstash-demo and let's also create the necessary files that we need:

mkdir go-logstash-demo && cd go-logstash-demo
touch docker-compose.yml
touch docker-setup/logstash/Dockerfile
touch docker-setup/logstash/logstash.conf
touch docker-setup/go-logger/Dockerfile
touch main.go

Here is the docker-compose.yml file that creates the ELK stack, Elastic Search, Logstash, and Kibana each into its own container, along with a container for the Go application.

# docker-compose.yml

version: "3.9"

services:
  elasticsearch:
    image: elasticsearch:7.1.0
    volumes:
      - ./esdata:/usr/share/elasticsearch/data
    ports:
      - "9200:9200"
      - "9300:9300"
    environment:
      - "discovery.type=single-node"
    networks:
      - elk

  logstash:
    build:
      context: .
      dockerfile: docker-setup/logstash/Dockerfile
    ports:
      - 9600:9600
      - 5228:5228
    environment:
      LOGSTASH_PORT: 5228
      LOGSTASH_INDEX: "test-index"
      ELASTIC_HOST: "elasticsearch:9200"
      ELASTIC_USERNAME: "elastic"
      ELASTIC_PASSWORD: "elastic"
    networks:
      - elk
    depends_on:
      - elasticsearch
    links:
      - elasticsearch

  kibana:
    image: kibana:7.1.0
    hostname: kibana
    ports:
      - "5601:5601"
    networks:
      - elk
    depends_on:
      - elasticsearch
    links:
      - elasticsearch
    environment:
      ELASTIC_HOST: "http://elasticsearch:9200"
      ELASTIC_USERNAME: "elastic"
      ELASTIC_PASSWORD: "elastic"

  go-app:
    container_name: go-app
    build:
      context: .
      dockerfile: docker-setup/go-logger/Dockerfile
    networks:
      - elk

networks:
  elk:
    driver: bridge

volumes:
  esdata:
    driver: local

Here is a custom Dockerfile for the Logstash container because we want to provide a custom logstash.conf file to it:

# docker-setup/logstash/Dockerfile

FROM docker.elastic.co/logstash/logstash-oss:7.1.0

COPY ./docker-setup/logstash/logstash.conf /etc/logstash/conf.d/

CMD logstash -f /etc/logstash/conf.d/logstash.conf

Here's an example of a basic logstash.conf file that creates a Logstash pipeline to collect logs from a TCP or UDP socket and output them to Elasticsearch:

# docker-setup/logstash/logstash.conf

input {
  tcp {
    host => "0.0.0.0"
    port => "${LOGSTASH_PORT}"
    codec => json_lines
  }
  udp {
    host => "0.0.0.0"
    port => "${LOGSTASH_PORT}"
    codec => json_lines
  }
}

output {
  stdout { codec => json_lines }
  elasticsearch {
      hosts => [ "${ELASTIC_HOST}" ]
      user => "${ELASTIC_USERNAME}"
      password => "${ELASTIC_PASSWORD}"
      codec => json_lines
      index => "${LOGSTASH_INDEX}"
  }
}

The logstash.conf config file is capable of supporting environment variables as well, which we are providing through our docker-compose.yml file. This pipeline listens for logs on TCP port 5228 and expects them to be in JSON format and outputs the logs to Elasticsearch in JSON.

We also need to create a Dockerfile for the Go application, as it would be using the internal Docker network to communicate with Logstash in order to push logs.

# docker-setup/go-logger/Dockerfile

FROM golang:1.19-alpine

WORKDIR /go-logstash-json

COPY . .

RUN go build -o out/logger *.go

CMD [ "./out/logger" ]

Pushing logs from a Go app to Logstash

Now that we have our ELK set up ready on our local, let's take a look at how we can push logs to it from a Go application using go-logstash.

Step 1: Create a Go application

In the root directory of go-logstash-demo, run:

go mod init example.com/go-logstash-demo

Step 2: Install go-logstash

The first step is to install go-logstash using the following command:

go get github.com/KaranJagtiani/go-logstash

Step 3: Test the Library

Next, we need to import the go-logstash package in our Go application and test the library:

# main.go

package main

import (
    logstash_logger "github.com/KaranJagtiani/go-logstash"
)

func main() {
    logger := logstash_logger.Init("logstash", 5228, "tcp", 5)

    payload := map[string]interface{}{
        "message": "TEST_MSG",
        "error":   false,
    }

    logger.Log(payload) // Generic log
    logger.Info(payload) // Adds "severity": "INFO"
    logger.Debug(payload) // Adds "severity": "DEBUG"
    logger.Warn(payload) // Adds "severity": "WARN"
    logger.Error(payload) // Adds "severity": "ERROR"
}

logger := logstash_logger.Init("logstash", 5228, "tcp", 5)

This line creates a new logger that will send logs to a Logstash instance running on logstash host in Docker through TCP port 5228 with a connection timeout of 5 seconds.

Conclusion

In conclusion, sending logs from a Go application to Logstash in the ELK stack is a powerful way to centralize and manage your application logs. With the help of the go-logstash library, it's easy to push logs to Logstash using either TCP or UDP. Logstash can then process and enrich the logs, making it easier to analyze and troubleshoot issues in your application.

Thank you for reading this beginner's guide on sending logs from a Go application to Logstash in the ELK stack with Docker setup. I hope that this guide has provided you with a useful overview of the process and has helped you get started with integrating Go and Logstash.

If you have any questions or feedback, please don't hesitate to leave a comment or reach out to me directly. I'm always happy to hear from readers and help in any way I can.

Thanks again for reading, and happy logging!