Hey folks, I've been deep in the weeds of automating everything lately, and it got me thinking about the ChatGPT plugin ecosystem. Remember when it launched? It felt like the next big platform play — like the GitHub Marketplace for Actions or the Jenkins plugin directory.
But lately, I'm not seeing the same momentum. My team was evaluating it for some internal tool exposure, like triggering CI/CD pipelines or checking security scan results from within a chat interface. The idea was slick: a natural language interface to our Jenkins or GitLab CI pipelines. Imagine asking, "What's the status of the backend build for feature-branch-X?" and having it pull real-time data. We even prototyped a simple plugin that could fetch pipeline statuses from our GitLab instance. The basic structure looked something like this in the `ai-plugin.json`:
```json
{
"schema_version": "v1",
"name_for_human": "CI/CD Pipeline Viewer",
"description_for_human": "Get real-time status of your GitLab CI pipelines.",
"api": {
"url": "https://our-internal-api.example.com/openapi.json"
},
"auth": {
"type": "service_http",
"authorization_type": "bearer"
},
"logo_url": "https://example.com/logo.png",
"contact_email": "devops@example.com",
"legal_info_url": "https://example.com/legal"
}
```
However, we hit several walls:
* The **discovery** is terrible. It's a walled garden inside the ChatGPT UI with no real community hub or review system.
* **Authentication** for internal tools became a nightmare. Service-level tokens? User delegation? It felt half-baked compared to OAuth flows we're used to in other platforms.
* **OpenAPI schema** requirements were rigid. Our internal APIs often don't have perfect OpenAPI specs, and the "just fix your spec" argument doesn't fly when velocity is key.
* Most importantly, the **usage patterns** never stuck. It was faster for us to just have a pinned dashboard or use a CLI tool like `glab`. The cognitive switch to a chat interface for operational data wasn't as smooth as we hoped.
Now, with the rise of **Custom GPTs** and the **Assistants API**, I'm wondering if plugins are essentially deprecated? The new models seem to favor function calling with defined schemas directly in the Assistant setup, which feels more flexible and closer to a code-driven approach we'd use in our pipelines.
So, my questions to the community:
* Are you still actively developing or maintaining ChatGPT plugins for internal or external use?
* Have you migrated functionality to Custom GPTs or the Assistants API? What was the lift like?
* Is the investment in learning and building plugins still worth it, or is that tech debt waiting to happen?
From a CI/CD perspective, I'm curious if anyone has built deeper integrations lately — like a plugin that can *trigger* a pipeline rollback or approve a deployment gate. Or are we all just using webhooks and traditional API calls from our existing automation tools?
Let's discuss! 🛠️
pipeline all the things
The plugin ecosystem was always a bit of a ghost town after the initial hype. OpenAI pushed it, then pivoted to GPTs and the store. That tells you everything.
For internal tool exposure, you're betting on a platform they aren't really maintaining. Why lock into their proprietary spec? You could build the same natural language interface with an open-source model and a local API, no plugin middleman required. More control, fewer deprecation surprises.
Your prototype sounds neat, but that's the problem. It's a prototype that works until the vendor decides to sunset the whole feature. Seen it before.
Prove it
The data point that matters is API traffic. OpenAI's plugin spec was deprecated in January 2025. The replacement, "actions," uses a different spec based on OpenAPI. If you're looking at the old `ai-plugin.json` format, you're already looking at deprecated tech.
For internal tools, your prototype's core value is the API, not the ChatGPT integration. You can expose that same API to an internal model (like an open-source one on `llama.cpp`) with a simple chat UI. It's more work initially, but you're not subject to a platform pivot. We run a similar setup for querying our Grafana logs.