AutoPipeline AI

Turn a plain-English sentence into a validated CI/CD pipeline.

AutoPipelineAI is a graduation project from the Faculty of Computers and Artificial Intelligence (FCAI), Cairo University, developed under the technical mentorship of Siemens Egypt and the supervision of Dr. Mohammad El-Ramly.

Writing CI/CD configuration by hand is slow and easy to get wrong: you have to learn platform-specific YAML, guess at the right actions and versions, and debug failures one push at a time. AutoPipelineAI does that work for you. Point it at a real codebase, describe what you want in plain English, and a multi-agent LLM system analyzes your project, plans a pipeline, generates GitHub Actions or GitLab CI YAML, validates it with real linters, and self-corrects until it is valid. The whole process streams to you live, and you approve every shell command and file write along the way.

It is delivered as a three-tier desktop product (an Electron / Next.js client, a NestJS backend-for-frontend, and a FastAPI multi-agent engine), split across the three repositories in this organization and composed into one runnable app by the AutoPipeline launcher.

_{with thanks to}

         

You don't need to touch the three repos individually. The AutoPipeline repo is a one-command launcher that clones all three, installs everything, and runs them together as a single desktop app:

git clone https://github.com/Auto-Pipeline-AI/AutoPipeline.git
cd AutoPipeline
npm run setup   # clone the 3 app repos + install dependencies
npm start       # launch agent + backend + frontend + the desktop window

You pick a provider and paste a key inside the app itself, encrypted in your OS keychain.

 

A deterministic Supervisor (zero LLM calls) routes between specialized agents (Planner, Analyzer, Researcher, Generator, Validator, Writer) on a LangGraph graph. The backend is a thin proxy and persistence layer, and the frontend never talks to the agent directly.

• Multi-agent engine: Planner, Analyzer, Researcher, Generator, Validator, and Writer agents orchestrated by a deterministic, zero-LLM Supervisor.
• Repository-aware: the Analyzer inspects your actual build files, test runners, and deploy configs so pipelines are grounded in reality, not guesses.
• Self-correcting reflexion loop: generated YAML is linted with actionlint (GitHub Actions) or the GitLab CI Lint API, and regenerated automatically on failure.
• Live web research: a ReAct Researcher agent looks up current action versions and syntax rather than relying on stale training data.
• Multi-platform: GitHub Actions and GitLab CI, from the same natural-language prompt.
• Multi-provider LLMs: OpenAI, Anthropic, Google Gemini, Groq, or any OpenAI-compatible endpoint (Ollama, vLLM, LM Studio); provider, model, and key are supplied per-request.
• Real-time NDJSON streaming: see reasoning tokens, tool calls, plans, and YAML drafts as they happen, not just the final result.
• Human-in-the-loop: explicit approval gates before running shell commands or writing files to disk.
• Security by design: commands are classified safe / modifying / dangerous before execution, and streamed payloads are scanned with entropy-based secret detection.
• Desktop-native: Electron provides a project folder picker, OS-keychain-encrypted API key storage, and a file-save bridge.

The pipeline-generation capability was evaluated end-to-end on six open-source repositories across four languages (Click and Peewee in Python, Hugo in Go, p-limit and Vite in JS/TS, Rustlings in Rust) using four LLMs (GLM, Qwen, Kimi, MiniMax). Each project was judged against 10 repository-specific functional requirements (240 requirements in total), asking a concrete question of every one: does the generated pipeline actually do what was asked?

Reliability varies by project and model, so the per-project breakdown matters:

Across all 240 evaluated requirements, not one model hallucinated. The error breakdown makes the point clearly: every failure was a Configuration Error or an Omission (a missing step), never an invented action, tool, or fact.

That result is by design, not luck. No single component is trusted to be correct on its own; every stage either grounds the model in something real or checks its output against something real before the run moves forward. The Analyzer reads your actual repo instead of guessing, the Researcher pulls live docs instead of relying on stale training data, and structured-output schemas keep responses on rails instead of free-form text. Most importantly, the Generator's YAML is never taken on faith: it is linted by real tools (actionlint, the GitLab CI Lint API), and on failure the concrete errors are fed back into a bounded reflexion loop that regenerates until the output is valid or the retry limit is hit. Nothing reaches the Writer, and nothing is written to disk, until it has survived that gate.

See the associated paper for the full per-project results.

Each service ships its own hermetic, boundary-mocked test suite that runs in CI. Together they add up to 459 automated tests:

LLM API keys are supplied per-request and stored encrypted in the OS keychain, and are never committed or logged. Shell commands are classified safe / modifying / dangerous and gated behind an explicit human approval prompt, and file writes require the same. All streamed payloads pass through entropy-based secret redaction before reaching the UI.

Built by Youssef Mohamed, Mohamed Ahmed Hemdan, Mahmoud Saleh Saad, Ahmed Mohamed Tolba, and Seif Gamal Abdelmonem, supervised by Dr. Mohammad El-Ramly (FCAI, Cairo University).

The project is also written up as a research paper, "AutoPipelineAI: Context-Aware CI/CD Pipeline Generation from Natural Language", available on arXiv (2606.06662).

One prompt turns into a validated GitHub Actions pipeline: the agent analyzes the repo, plans, streams the reasoning and YAML live, self-corrects, and asks for approval before writing the file: