← Services

Custom ChatGPT Plugins (MCP Integration)

Your systems, inside ChatGPT.

A custom ChatGPT plugin is an MCP server. We build yours over the API you already run, over a legacy system that has no API at all, or as a new backend that exists to do one job — and the same server works in Claude and Cursor without a second build.

What you get

  • A ChatGPT plugin your team installs and uses
  • One MCP server, also usable in Claude and Cursor
  • Over your existing API, a legacy system or a new backend
  • Interactive tables and forms in the chat, not text
  • You own the server, the widgets and the specs

Best forBusinesses whose own systems ChatGPT cannot reach yet

FromFree discovery, then €85/h — scoped by integration complexity

Start a conversation

Request a callback

Leave your details and a named senior engineer gets back to you within one business day. No sales script, no obligation.

By sending this, you agree to our privacy policy. We use your details only to reply.

What this is

Your people already work in ChatGPT. What they cannot do there is touch your business: ChatGPT can discuss your orders, invoices, or stock levels in the abstract, but it cannot look one up, and it must not change one blindly. A custom plugin closes that gap — without touching what runs in production today.

Underneath, that plugin is a Model Context Protocol server. We put one in front of your existing REST API, GraphQL endpoint, database, or legacy application, expose a deliberate set of tools, and — where it earns its place — give those tools a real interface. Because MCP is the same standard Claude and Cursor speak, the plugin you commission for ChatGPT is not a ChatGPT-only asset.

What a ChatGPT plugin actually is in 2026

It is an MCP server with a listing. That is the whole answer, and it is why we sell plugin work and MCP integration as one service rather than two.

The 2023 plugin platform — the ai-plugin.json manifest and the OpenAPI spec behind it — is gone; OpenAI retired it in 2024. What replaced it arrived in stages. In March 2025 OpenAI added MCP support across the Agents SDK, the Responses API, and the ChatGPT desktop app. In October 2025 the Apps SDK shipped in preview, built on MCP, together with a developer mode that gives ChatGPT full MCP client support for read and write tools. In December 2025 the App Directory opened. On 9 July 2026 OpenAI migrated that directory to the Plugin Directory, where a single plugin listing can bundle apps, skills, and app templates, and appears across ChatGPT web, ChatGPT desktop, ChatGPT Work, and Codex.

So there is no longer a fork in the road. Commissioning “a ChatGPT plugin” and commissioning “an MCP integration” produce the same artifact: a server that speaks MCP, deployed remotely, packaged for the directory if you want a public listing and kept private if you do not.

Four ways we build it

Which shape fits depends on what already exists on your side. Discovery ends with that decision written down.

Most common

Wrapper server

A server in front of what you already expose.

  • Speaks to your existing REST, GraphQL or SQL surface
  • Zero changes to the running application
  • Fastest path to a working plugin
  • Tool surface designed, not auto-generated from endpoints

Legacy bridge

For systems that never had a usable API.

  • SOAP endpoints, on-premise databases, file drops
  • Desktop and terminal applications driven directly
  • We build the missing interface, then the tools on top
  • The legacy system stays untouched and unrewritten

Embedded mode

MCP as a second mode of your own binary.

  • The application itself answers as an MCP server
  • One codebase, one deployment, no translation layer
  • The binzaar pattern: one Go binary, three modes
  • Best when we also own or maintain the application

Purpose-built backend

A new backend that exists to do one job.

  • No existing system to wrap — we build the whole thing
  • Scoped to a single use case, not a general platform
  • Its own storage, its own auth, its own deployment
  • The smallest surface that answers the question well
Interfaces in the chat, not walls of text

A tool that returns JSON forces the assistant to describe your data in prose. A tool that returns an interface lets your people act on it. When the assistant lists open invoices, it can hand back a sortable table with per-row actions; when it needs structured input, a validated form the user submits straight back as a tool call.

This is a standard, not a trick that breaks on the next host update. On 26 January 2026, Anthropic and OpenAI standardised interactive UI as MCP Apps (SEP-1865) — the first official extension to the Model Context Protocol, carried by the io.modelcontextprotocol/ui namespace. A widget built once renders in any compliant host: ChatGPT, Claude, VS Code, Cursor, Postman, or the private workspace we build for you.

Our open-source library gomukit is how we ship those interfaces. It generates table, form, card, and card-list widgets as self-contained HTML resources embedded in the server binary — themed to the host, formatted to the host’s locale and timezone, locked down by a strict Content Security Policy, with no external CDN dependency at all.

A validated form rendered by gomukit inside an assistant conversationChange Ada's role to adminHere is the record — edit and submit:Message the assistant
A form widget inside the thread: typed fields, client-side validation, server-side error mapping. Submitting it calls the tool directly — no copy-paste back into the chat.
A responsive grid of record cards rendered by gomukit inside an assistant conversationShow me the users I can editFour users. Filter, sort, or act on any card:Message the assistant
The same data as a card grid, with filtering, sorting and per-item actions. Built once, rendered by whichever host your team uses.
Proof: the MCP servers we ship in the open

We point at working software. Every pattern on this page is one we run in our own repositories, under the MIT licence, in public.

binzaar

Open source

A single-binary local app store: browse a GitHub-hosted catalog, install release binaries with SHA-256 verification, update, and scaffold new microapps. One binary runs as a terminal UI, an MCP stdio server, and an HTTP catalog server — the embedded-mode pattern described above, including in-chat widgets.

GobbolttviewMCP stdioMCP Apps
github.com/Techthos/binzaar

gomukit

Open source · pre-release

The Go library behind our in-chat interfaces: table, form, card and card-list widgets emitted as self-contained HTML, SDK-agnostic at the core with an adapter for the official MCP go-sdk. Compliant with the io.modelcontextprotocol/ui extension, revision 2026-01-26.

GoTypeScriptesbuildMCP Apps (SEP-1865)
github.com/Techthos/gomukit

clockwork

Open source

Our flagship dual-mode time tracker: an MCP server that lets an assistant log work in natural language and turn git commits into worklogs, plus a keyboard-driven terminal UI over the same data.

GoMCP stdio
github.com/Techthos/clockwork
The standards we build to

Building on the published specification is what keeps your plugin portable. A bespoke assistant integration is tied to one vendor’s host; an MCP server is not.

MCP core

Tools, resources and prompts modelled properly — streamable HTTP for the remote deployment ChatGPT requires, stdio where a local process is enough.

MCP Apps (SEP-1865)

The official UI extension, io.modelcontextprotocol/ui, revision 2026-01-26 — the same spec our gomukit library implements.

ChatGPT distribution

Apps SDK packaging, developer-mode testing, and a Plugin Directory listing if you want one — or a private plugin your staff install and nobody else sees.

Host compatibility

ChatGPT and Codex, Claude, Cursor, VS Code and Postman, plus self-hosted Open WebUI and LibreChat workspaces.

Security and what the assistant is actually allowed to do

The reason most internal systems are still not reachable from ChatGPT is not capability, it is permissions. We treat the tool surface as an authorization boundary, not a prompt.

Read-side first

Write operations ship after the read path is proven, each behind an explicit scope and, where it matters, a confirmation step in the widget.

Real authentication

Per-user OAuth on the remote server ChatGPT connects to, service credentials on local ones. Never one shared admin token standing in for every caller.

Enforced server-side

Every tool checks who is calling and what they may touch in the server, where a prompt cannot argue with it. Instructions in a document are not permissions.

Sandboxed widgets

In-chat widgets are self-contained documents under a strict CSP with no external requests — nothing phones home from inside your conversation.

Auditable calls

Tool invocations are logged with caller, arguments and result status, so you can answer what the assistant did and when.

EU by default

EU data residency, signed DPAs, disclosed sub-processors — the same posture as every other Techthos engagement.

How we engage & pricing

Per-milestone and stop-anywhere, billed by effort at €85/hour. What a plugin costs depends on its complexity — how many tools, how clean the existing interface is, whether write operations and interactive widgets are in scope — so we scope it after Discovery rather than guessing at a fixed price.

  1. DiscoveryFree
    We read your API, schema or legacy system, agree which hosts must reach it, and deliver a written tool map with a complexity verdict
  2. Plugin specBy effort · €85/h
    The tool surface on paper: each tool, its arguments, its permission, its widget — usable to brief any team · about 1 week
  3. Pilot pluginBy effort · €85/h
    A working MCP server with the first tools, installed in ChatGPT developer mode, read-side only · 1–2 weeks
  4. Full buildBy effort · €85/h
    The complete tool set, write operations, in-chat widgets, OAuth, deployment, CI, optional directory listing and handover · 2–8 weeks
  5. Maintenancefrom €70 / mo
    Optional retainer: spec revisions, host compatibility, and the small changes that follow

Billed by effort at €85/hour; the total follows complexity and is fixed per SOW after the free Discovery. You own the server source, the widget definitions, the specifications and the deployment. Stop after any milestone — the tool map alone is a usable artifact.