Support AI Agent tools (eg. OpenAI Codex, Claude Code, GitHub Copilot, Gemini CLI, etc) and integrations (eg. Model Context Protocol (MCP))

[0xdevalias]

Using this as a bit of a collective meta-issue to bring together some of the other disparate issues related to essentially better integrations with an Agentic AI tool such as OpenAI Codex, Claude Code, GitHub Copilot, Gemini CLI, etc; as well as more generic integration protocols such as Model Context Protocol (MCP).

Relevant issue searches

• https://github.com/jehna/humanify/issues?q=is%3Aissue%20state%3Aopen%20(%22Model%20Context%20Protocol%22%20OR%20MCP)
• https://github.com/jehna/humanify/issues?q=is%3Aissue%20state%3Aopen%20(%22Codex%22%20OR%20%22Claude%20Code%22%20OR%20%22Gemini%20CLI%22%20OR%20%22Copilot%22)

Non-exhaustive list of related issues

• Add an API provider abstraction layer to easily support more services/models/APIs #400
  • OpenAI Agents SDK: Add an API provider abstraction layer to easily support more services/models/APIs #400 (comment)
  • Vercel AI SDK v5 + Vercel AI Gateway: Add an API provider abstraction layer to easily support more services/models/APIs #400 (comment)
• Suggestions : Alternative Models, Batch and Auto-renaming #84
• Idea from @neoOpus: Evolve HumanifyJS into an AI-Powered, Integrated Reverse Engineering & Code Transformation Assistant #414
• Copilot support #481
• Gemini CLI #503

[0xdevalias]

Most directly interesting/relevant here from the recent OpenAI announcements is probably the Codex SDK:

• https://developers.openai.com/codex/sdk/

  • Codex SDK

  • Programmatically control local Codex agents

But the Agent Builder and Agents SDK might also be useful:

• https://platform.openai.com/docs/guides/agent-builder

  • Agent Builder

  • Visually assemble, debug, and export multi-step agent workflows from the playground.

  • https://platform.openai.com/agent-builder
• https://platform.openai.com/docs/guides/agents-sdk

  • Agents SDK

  • This library makes it straightforward to build agentic applications—where a model can use additional context and tools, hand off to other specialized agents, stream partial results, and keep a full trace of what happened.

[0xdevalias]

Since then, the AI landscape has evolved dramatically, making my original, out‑of‑scope ambitions more attainable. I now believe that developing an MCP for HumanifyJS is essential, and that integrating ACP could create a near‑automatic, recurrent workflow for handling the various stages efficiently.

@neoOpus Agreed that something like MCP would make a lot of sense for exposing the humanify-specific features (or maybe even just webcrack directly, as a lot of what humanify adds is just extra 'LLM glue code' on top of what webcrack does) to various agents/LLM tools without needing to constantly 'reinvent the wheel'.

I'm less directly familiar with Agent Communication Protocol (ACP) and the benefits/implications of that, but wouldn't be surprised if there was some additional benefit there too:

• https://agentcommunicationprotocol.dev/introduction/welcome

  • The Agent Communication Protocol (ACP) is an open protocol for agent interoperability that solves the growing challenge of connecting AI agents, applications, and humans. Modern AI agents are often built in isolation, across different frameworks, teams, and infrastructures. This fragmentation slows innovation and makes it harder for agents to work together effectively. ACP solves this by enabling agents to communicate through a standardized RESTful API

It seems ACP is now part of the Agent 2 Agent Protocol (A2A) now too:

• https://github.com/orgs/i-am-bee/discussions/5

  • ACP Joins Forces with A2A Under the Linux Foundation

• https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/

  • Announcing the Agent2Agent Protocol (A2A)

Unless you meant Agent Client Protocol (ACP), which seems like it might be a different thing again:

• https://agentclientprotocol.com/overview/introduction

  • The Agent Client Protocol standardizes communication between code editors/IDEs, and coding agents (programs that use generative AI to autonomously modify code).

  • AI coding agents and editors are tightly coupled but interoperability isn’t the default. Each editor must build custom integrations for every agent they want to support, and agents must implement editor-specific APIs to reach users.

  • ACP solves this by providing a standardized protocol for agent-editor communication, similar to how the Language Server Protocol (LSP) standardized language server integration.

  • Agents that implement ACP work with any compatible editor. Editors that support ACP gain access to the entire ecosystem of ACP-compatible agents. This decoupling allows both sides to innovate independently while giving developers the freedom to choose the best tools for their workflow.

• https://github.com/agentclientprotocol/agent-client-protocol

Some other more recent approaches that might be worth considering (whether instead of MCP, or in addition to it), are things like AGENTS.md + CLI tools:

• https://agents.md/

  • AGENTS.md

  • A simple, open format for guiding coding agents,
    used by over 20k open-source projects.

  • Think of AGENTS.md as a README for agents: a dedicated, predictable place to provide the context and instructions to help AI coding agents work on your project.

And the newer more standardised version of that, Claude Skills:

• https://claude.com/blog/skills

  • Introducing Agent Skills

  • Claude can now use Skills to improve how it performs specific tasks. Skills are folders that include instructions, scripts, and resources that Claude can load when needed.

• https://github.com/anthropics/skills

  • Skills

  • Public repository for Skills

  • Skills are folders of instructions, scripts, and resources that Claude loads dynamically to improve performance on specialized tasks. Skills teach Claude how to complete specific tasks in a repeatable way, whether that's creating documents with your company's brand guidelines, analyzing data using your organization's specific workflows, or automating personal tasks.

• https://github.com/BehiSecc/awesome-claude-skills

  • Awesome Claude Skills

  • A curated list of Claude Skills.

  • If you have suggestions, improvements, or new resources to add:

Or what seems to be a bit of a combination of Skills + MCP in a more defined package sort of way, Gemini CLI extensions:

• https://blog.google/technology/developers/gemini-cli-extensions/

  • Now open for building: Introducing Gemini CLI extensions

  • With extensions, you can connect the power of Gemini to your everyday workflows and the tools you use most, making Gemini CLI uniquely yours.

• https://geminicli.com/extensions/about/

  • About Extensions

  • Connect your favorite tools and personalize your AI-powered command line

  • Anatomy of an extension

    Bundle MCP servers, context files, and custom commands into a simple package that teaches Gemini how to use any tool

• https://geminicli.com/extensions/

  • Browse Extensions

• https://geminicli.com/docs/extensions/getting-started-extensions/

  • Getting Started with Gemini CLI Extensions

  • This guide will walk you through creating your first Gemini CLI extension. You’ll learn how to set up a new extension, add a custom tool via an MCP server, create a custom command, and provide context to the model with a GEMINI.md file.

  • https://geminicli.com/docs/extensions/getting-started-extensions/#gemini-extensionjson

    • gemini-extension.json

    • This is the manifest file for your extension. It tells Gemini CLI how to load and use your extension.

And then, if you wanted to edge back towards individual agent harnesses / similar; you could potentially consider looking at things like the Codex SDK and similar for other agents:

• https://developers.openai.com/codex/sdk/

  • Codex SDK

  • Programmatically control local Codex agents

  • Aside from using Codex through the different interfaces like the Codex CLI, IDE extension or Codex Web, you can also programmatically control Codex.

• https://www.anthropic.com/engineering/building-agents-with-the-claude-agent-sdk

  • Building agents with the Claude Agent SDK

  • The Claude Agent SDK is a collection of tools that helps developers build powerful agents on top of Claude Code.

  • https://docs.claude.com/en/api/agent-sdk/overview

    • Agent SDK overview

  • https://docs.claude.com/en/docs/claude-code/sdk/migration-guide

    • Migrate to Claude Agent SDK

    • Guide for migrating the Claude Code TypeScript and Python SDKs to the Claude Agent SDK

    • The Claude Code SDK has been renamed to the Claude Agent SDK and its documentation has been reorganized. This change reflects the SDK’s broader capabilities for building AI agents beyond just coding tasks.

• https://google.github.io/adk-docs/

  • Agent Development Kit

  • Agent Development Kit (ADK) is a flexible and modular framework for developing and deploying AI agents. While optimized for Gemini and the Google ecosystem, ADK is model-agnostic, deployment-agnostic, and is built for compatibility with other frameworks. ADK was designed to make agent development feel more like software development, to make it easier for developers to create, deploy, and orchestrate agentic architectures that range from simple tasks to complex workflows.

• etc

Originally posted by @0xdevalias in #503 (comment)