starred/humanify

Fork 0

mirror of https://github.com/jehna/humanify.git synced 2026-05-01 11:36:06 +03:00

[GH-ISSUE #503] Gemini CLI #85

New issue

Open

opened 2026-03-03 13:52:52 +03:00 by kerem · 6 comments

kerem commented

2026-03-03 13:52:52 +03:00

Owner

Originally created by @neoOpus on GitHub (Jun 29, 2025).
Original GitHub issue: https://github.com/jehna/humanify/issues/503

Google recently launched an impressive, free product offering a vast context of over one million tokens, which could serve as the backbone for this project—eliminating the need for APIs and transforming this mode from mere JSON request-response exchanges into a comprehensive system capable of managing files and the entire project. This innovation could revolutionize the script’s ability to autonomously maintain projects and perform minimal-input reverse engineering—a set-and-forget solution that downloads obfuscated files, extracts them if packaged (e.g., .crx), processes them, and generates references and supporting files to ensure version consistency. I experimented with it briefly but haven’t explored its full potential; it might also integrate with command-line tools to handle complex tasks seamlessly.

I hope this project adopts this approach instead of relying on the current, limited API method.

Originally created by @neoOpus on GitHub (Jun 29, 2025). Original GitHub issue: https://github.com/jehna/humanify/issues/503 Google recently launched an impressive, free product offering a vast context of over one million tokens, which could serve as the backbone for this project—eliminating the need for APIs and transforming this mode from mere JSON request-response exchanges into a comprehensive system capable of managing files and the entire project. This innovation could revolutionize the script’s ability to autonomously maintain projects and perform minimal-input reverse engineering—a set-and-forget solution that downloads obfuscated files, extracts them if packaged (e.g., .crx), processes them, and generates references and supporting files to ensure version consistency. I experimented with it briefly but haven’t explored its full potential; it might also integrate with command-line tools to handle complex tasks seamlessly. I hope this project adopts this approach instead of relying on the current, limited API method.

kerem commented

2026-03-03 13:52:53 +03:00

Author

Owner

@0xdevalias commented on GitHub (Jun 30, 2025):

Google recently launched an impressive, free product offering a vast context of over one million tokens

https://blog.google/technology/developers/introducing-gemini-cli-open-source-ai-agent/
- Gemini CLI: your open-source AI agent
- Free and open source, Gemini CLI brings Gemini directly into developers’ terminals — with unmatched access for individuals.
https://github.com/google-gemini/gemini-cli
- Gemini CLI
- An open-source AI agent that brings the power of Gemini directly into your terminal.
- Authenticate: When prompted, sign in with your personal Google account. This will grant you up to 60 model requests per minute and 1,000 model requests per day using Gemini.
- If you need to use a specific model or require a higher request capacity, you can use an API key
https://cloud.google.com/gemini/docs/codeassist/gemini-cli
- Gemini CLI
- The Gemini command line interface (CLI) is an open source AI agent that provides access to Gemini directly in your terminal. The Gemini CLI uses a reason and act (ReAct) loop with your built-in tools and local or remote MCP servers to complete complex use cases like fixing bugs, creating new features, and improving test coverage. While the Gemini CLI excels at coding, it's also a versatile local utility that you can use for a wide range of tasks, from content generation and problem solving to deep research and task management.
  
  The Gemini CLI is available for Gemini Code Assist for individuals, Standard, and Enterprise editions.
  
  Quotas are shared between Gemini CLI and Gemini Code Assist agent mode.

which could serve as the backbone for this project—eliminating the need for APIs and transforming this mode from mere JSON request-response exchanges into a comprehensive system capable of managing files and the entire project. This innovation could revolutionize the script’s ability to autonomously maintain projects and perform minimal-input reverse engineering—a set-and-forget solution that downloads obfuscated files, extracts them if packaged (e.g., .crx), processes them, and generates references and supporting files to ensure version consistency.

@neoOpus This sounds quite similar to the following issue, and may stretch the scope of humanify beyond its current intent:

https://github.com/jehna/humanify/issues/414

I hope this project adopts this approach instead of relying on the current, limited API method.

@neoOpus While I haven't thought about this too deeply (and humanify technically isn't my project to guide the direction of (see also: #358)), I don't personally feel like the current API method is necessarily 'limited'; but more that what you're proposing feels like it could be an entirely different tool/scope than what humanify is looking to solve.

Like, off the top of my head, it could be that humanify ends up being just one of many tools in some new project that fulfills those 'larger scope' aspects you're talking about; in the same way that humanify leverages webcrack as a tool itself.

I kind of think about this in terms of the 'unix tool philosophy':

https://en.wikipedia.org/wiki/Unix_philosophy
- Make each program do one thing well. To do a new job, build afresh rather than complicate old programs by adding new "features".
- Write programs that do one thing and do it well.
- Write programs to work together.

Assuming those thoughts do tend out to be a good approach, then the sorts of changes that I think would be relevant within humanify itself could be adding the ability for it to act like a tool via Model Context Protocol (MCP) or similar, so that it could be more easily integrated into other tools via a standardised interface.

https://www.anthropic.com/news/model-context-protocol
- Introducing the Model Context Protocol
https://modelcontextprotocol.io/
- Model Context Protocol (MCP)

Another protocol that could be relevant in this space is the Agent2Agent protocol:

https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/
- Announcing the Agent2Agent Protocol (A2A)

See Also:

@0xdevalias commented on GitHub (Jun 30, 2025): > Google recently launched an impressive, free product offering a vast context of over one million tokens - https://blog.google/technology/developers/introducing-gemini-cli-open-source-ai-agent/ - > Gemini CLI: your open-source AI agent - > Free and open source, Gemini CLI brings Gemini directly into developers’ terminals — with unmatched access for individuals. - https://github.com/google-gemini/gemini-cli - > Gemini CLI - > An open-source AI agent that brings the power of Gemini directly into your terminal. - > Authenticate: When prompted, sign in with your personal Google account. This will grant you up to 60 model requests per minute and 1,000 model requests per day using Gemini. - > If you need to use a specific model or require a higher request capacity, you can use an API key - https://cloud.google.com/gemini/docs/codeassist/gemini-cli - > Gemini CLI - > The [Gemini command line interface (CLI)](https://github.com/google-gemini/gemini-cli) is an open source AI agent that provides access to Gemini directly in your terminal. The Gemini CLI uses a reason and act (ReAct) loop with your built-in tools and local or remote MCP servers to complete complex use cases like fixing bugs, creating new features, and improving test coverage. While the Gemini CLI excels at coding, it's also a versatile local utility that you can use for a wide range of tasks, from content generation and problem solving to deep research and task management. > > The Gemini CLI is available for Gemini Code Assist for individuals, Standard, and Enterprise editions. > > [Quotas](https://cloud.google.com/gemini/docs/quotas?authuser=1) are shared between Gemini CLI and Gemini Code Assist agent mode. --- > which could serve as the backbone for this project—eliminating the need for APIs and transforming this mode from mere JSON request-response exchanges into a comprehensive system capable of managing files and the entire project. This innovation could revolutionize the script’s ability to autonomously maintain projects and perform minimal-input reverse engineering—a set-and-forget solution that downloads obfuscated files, extracts them if packaged (e.g., .crx), processes them, and generates references and supporting files to ensure version consistency. @neoOpus This sounds quite similar to the following issue, and may stretch the scope of `humanify` beyond its current intent: - https://github.com/jehna/humanify/issues/414 --- > I hope this project adopts this approach instead of relying on the current, limited API method. @neoOpus While I haven't thought about this too deeply (and `humanify` technically isn't my project to guide the direction of (see also: #358)), I don't personally feel like the current API method is necessarily 'limited'; but more that what you're proposing feels like it could be an entirely different tool/scope than what `humanify` is looking to solve. Like, off the top of my head, it could be that `humanify` ends up being just one of many tools in some new project that fulfills those 'larger scope' aspects you're talking about; in the same way that `humanify` leverages `webcrack` as a tool itself. I kind of think about this in terms of the 'unix tool philosophy': - https://en.wikipedia.org/wiki/Unix_philosophy - > Make each program do one thing well. To do a new job, build afresh rather than complicate old programs by adding new "features". - > Write programs that do one thing and do it well. - > Write programs to work together. Assuming those thoughts do tend out to be a good approach, then the sorts of changes that I think would be relevant within `humanify` itself could be adding the ability for it to act like a tool via Model Context Protocol (MCP) or similar, so that it could be more easily integrated into other tools via a standardised interface. - https://www.anthropic.com/news/model-context-protocol - > Introducing the Model Context Protocol - https://modelcontextprotocol.io/ - > Model Context Protocol (MCP) Another protocol that could be relevant in this space is the Agent2Agent protocol: - https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/ - > Announcing the Agent2Agent Protocol (A2A) --- See Also: - https://github.com/jehna/humanify/issues/84 - https://github.com/jehna/humanify/issues/400 - https://github.com/jehna/humanify/issues/414 - https://github.com/jehna/humanify/issues/481 - https://github.com/jehna/humanify/issues/636

kerem commented

2026-03-03 13:52:53 +03:00

Author

Owner

@shali1995 commented on GitHub (Jul 25, 2025):

this is a must. who can do it?

@shali1995 commented on GitHub (Jul 25, 2025): this is a must. who can do it?

kerem commented

2026-03-03 13:52:53 +03:00

Author

Owner

@neoOpus commented on GitHub (Jul 26, 2025):

this is a must. who can do it?

I think I've found a way to do it without even altering the source code of Humanify! I will take the time as soon as possible to create a tutorial on how to do this (hopefully tomorrow)

@neoOpus commented on GitHub (Jul 26, 2025): > this is a must. who can do it? I think I've found a way to do it without even altering the source code of Humanify! I will take the time as soon as possible to create a tutorial on how to do this (hopefully tomorrow)

kerem commented

2026-03-03 13:52:53 +03:00

Author

Owner

@0xdevalias commented on GitHub (Oct 8, 2025):

I think I've found a way to do it without even altering the source code of Humanify!

@neoOpus Curious if you ever got around to exploring that idea further / writing up instructions for it?

@0xdevalias commented on GitHub (Oct 8, 2025): > I think I've found a way to do it without even altering the source code of Humanify! @neoOpus Curious if you ever got around to exploring that idea further / writing up instructions for it?

kerem commented

2026-03-03 13:52:53 +03:00

Author

Owner

@neoOpus commented on GitHub (Nov 1, 2025):

I think I've found a way to do it without even altering the source code of Humanify!

@neoOpus Curious if you ever got around to exploring that idea further / writing up instructions for it?

I regret to share that my mother passed away last week after a prolonged struggle, which plunged me into deep depression since she's been in a coma on July 25-26. I hope to recover soon and regain clarity, though I currently feel overwhelmed, scattered more than ever, and disorganized.

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. I will attempt to recall my past efforts while advancing the plans to establish a workflow that leverages HumanifyJS, AI agents, and other tools to reliably reproduce maintainable source code across versions.

@neoOpus commented on GitHub (Nov 1, 2025): > > I think I've found a way to do it without even altering the source code of Humanify! > > [@neoOpus](https://github.com/neoOpus) Curious if you ever got around to exploring that idea further / writing up instructions for it? I regret to share that my mother passed away last week after a prolonged struggle, which plunged me into deep depression since she's been in a coma on July 25-26. I hope to recover soon and regain clarity, though I currently feel overwhelmed, scattered more than ever, and disorganized. 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. I will attempt to recall my past efforts while advancing the plans to establish a workflow that leverages HumanifyJS, AI agents, and other tools to reliably reproduce maintainable source code across versions.

kerem commented

2026-03-03 13:52:53 +03:00

Author

Owner

@0xdevalias commented on GitHub (Nov 4, 2025):

I regret to share that my mother passed away last week after a prolonged struggle, which plunged me into deep depression

@neoOpus Oh true; sorry to hear that :(

I hope to recover soon and regain clarity, though I currently feel overwhelmed, scattered more than ever, and disorganized.

@neoOpus nods, totally understandable.

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

I also created this more general issue as a bit of a 'catch all' for these sorts of things:

https://github.com/jehna/humanify/issues/636

I will attempt to recall my past efforts while advancing the plans to establish a workflow that leverages HumanifyJS, AI agents, and other tools to reliably reproduce maintainable source code across versions.

@neoOpus Sounds good. Definitely still keen to hear any updates / progress you make in that space when you do (but obviously no pressure too)

@0xdevalias commented on GitHub (Nov 4, 2025): > I regret to share that my mother passed away last week after a prolonged struggle, which plunged me into deep depression @neoOpus Oh true; sorry to hear that :( --- > I hope to recover soon and regain clarity, though I currently feel overwhelmed, scattered more than ever, and disorganized. @neoOpus _nods_, totally understandable. --- > 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)](https://microsoft.github.io/language-server-protocol/) 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](https://github.com/search?q=path%3AAGENTS.md&type=code). - > 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 I also created this more general issue as a bit of a 'catch all' for these sorts of things: - https://github.com/jehna/humanify/issues/636 --- > I will attempt to recall my past efforts while advancing the plans to establish a workflow that leverages HumanifyJS, AI agents, and other tools to reliably reproduce maintainable source code across versions. @neoOpus Sounds good. Definitely still keen to hear any updates / progress you make in that space when you do (but obviously no pressure too)