Top New Open-Source GitHub Projects This Week: AI Agents, Web Tools & Dev Kits #212

Key Concepts

• LLM Council: A system for aggregating and synthesizing responses from multiple Large Language Models (LLMs) to achieve a more robust and less biased answer.
• Code Mode: A library that enables AI agents to execute code to call various tools through a single code block, simplifying tool integration.
• Agent Development Kit (ADK) for Go: A toolkit for building, orchestrating, evaluating, and deploying AI agents using the Go programming language.
• Memory: A native SQL-based memory layer for AI agents, providing persistent, queryable memory without vendor lock-in.
• Cognet: A Python-based memory engine that builds a persistent knowledge graph and vector store for AI agents, enabling richer recall.
• Zappy: An automatic API discovery tool that logs API calls from web applications and converts them into structured tools for AI agents.
• Uptime Kit: A self-hosted, open-source uptime monitor for services, providing real-time dashboards and alerts.
• Agent SOP (Standard Operating Procedures): A markdown-based format for defining AI agent workflows, ensuring reliability and repeatability.
• Blueprint MCP: A tool that autogenerates architecture diagrams from codebases, visualizing system structure.
• Agent Sandbox Skill: A safe and flexible sandbox environment for AI agents to execute code and experiments without risking the host system.

Project 1: LLM Council

LLM Council is an open-source local web application designed to improve the quality and reliability of answers generated by Large Language Models (LLMs). It addresses the limitations of single LLM responses by creating a "council" of LLMs.

Key Points:

• Mechanism:
  • A user prompt is broadcast to multiple LLMs via the Open Router service.
  • Each LLM independently generates a response.
  • Responses are then anonymously reviewed and ranked by other LLMs based on accuracy and insight.
  • A designated "chairman" LLM synthesizes all responses, critiques, and rankings into a final, consolidated answer.
• Benefits:
  • Diverse Perspectives: Leverages the unique strengths and weaknesses of different LLMs.
  • Peer-Review Style Vetting: Reduces hallucinations and bias by having models critique each other.
  • Consensus-Driven Answers: Produces more robust and reliable outputs.
• Technical Details:
  • Backend: Python with FastAPI.
  • HTTP Client: async HTTPX.
  • Frontend: React.
  • Data Storage: Conversation logs are stored as JSON files.
• Use Cases: Building tools, research, working with complex prompts requiring robust answer generation and safer reasoning.

Project 2: Code Mode

Code Mode is a plug-and-play library that simplifies tool integration for AI agents by allowing them to execute a single block of code to call multiple tools. It operates under the Universal Tool Calling Protocol (UTCP).

Key Points:

• Core Functionality: Instead of an agent making numerous individual tool calls (e.g., "use tool A then B then C"), it writes a small script that executes all necessary actions.
• Mechanism:
  • Developers import the CodeMode client.
  • Tools (APIs, CLIs, etc.) are registered with the library.
  • An AI agent is instructed to run a script (in TypeScript or Python) that calls these registered tools as needed.
  • The CodeMode library executes this script within a secure sandbox environment.
• Features:
  • Sandbox Execution: Provides timeouts, security isolation, and full logging for executed code.
  • Reduced Complexity: Exposes a single "code executor" tool to the model, rather than hundreds of individual tools, preventing function call overload.
• Benefits:
  • Efficiency: Significantly reduces operations (60-90% fewer than traditional tool chaining).
  • Speed: Speeds up workflows.
  • Security: Keeps tool execution secure and manageable.
• Use Cases: Advanced AI agents, orchestration systems, automation pipelines requiring flexible and reliable tool integration.

Project 3: ADK Go (Agent Development Kit for Go)

ADK Go is a free, open-source toolkit from Google that enables developers to build, orchestrate, evaluate, and deploy sophisticated AI agents using the Go programming language. It treats agents as first-class building blocks.

Key Points:

• Agent-Centric Design: Agents are defined as autonomous units using native Go idioms.
• Agent Types:
  • LLM Agents: For reasoning using language models.
  • Deterministic Workflow Controllers: For sequential, parallel, or loop-based predictable tasks.
• Integration Capabilities: Agents can utilize tools, APIs, code execution, and external services. They can also delegate work to other agents.
• Code-First Approach: Logic, orchestration, and tool integration are managed as standard Go code, offering:
  • Type safety.
  • Concurrency support.
  • Easy versioning.
  • Ability to run agents alongside existing Go services.
• Flexibility:
  • Model Agnostic: Supports plugging in different LLM backends (though optimized for Google's models).
  • Deployment Agnostic: Can be deployed locally, in containers, or on cloud services like Cloud Run or Google managed runtimes.
• Target Audience: Developers, back-end teams, and AI tool builders who prefer Go for integrating AI agents into applications.

Project 4: Memory (CQL Native Memory Layer)

Memory is an open-source memory engine by Gibson AI that provides a persistent, queryable memory layer for AI agents. It integrates with any LLM or agent framework with a single line of code (memory.enable).

Key Points:

• Persistence: Stores all memory in standard SQL databases (SQLite, PostgreSQL, MySQL) that the user controls.
• Transparency and Portability: Avoids black-box vector stores and vendor lock-in. Memory can be exported or backed up like any other database.
• Underlying Technology: Uses structured entity extraction, relationship mapping, and full-text CQL search.
• Memory Types:
  • Short-term Working Memory: For immediate context.
  • Long-term Memory: For persistent information.
  • Hybrid Approach: Allows intelligent promotion of important information over time.
• Integration: Hooks into popular LLM frameworks and agent systems (e.g., OpenAI, Anthropic, LiteLLM).
• Benefits: Enables AI agents to remember, adapt, and grow smarter over time, providing contextual and personalized experiences.
• Use Cases: Developers, researchers, and anyone building contextual, personalized AI assistants.

Project 5: Cognet (Smart Memory Layer)

Cognet is an open-source Python-based memory engine that helps build a persistent knowledge graph and vector store for AI agents. It goes beyond simple Retrieval Augmented Generation (RAG) by extracting structured entities and relationships.

Key Points:

• Knowledge Representation: Stores data in a graph database and a vector store, capturing entities, relations, and semantic connections.
• Data Sources: Processes data from PDFs, transcripts, documents, and images.
• Enhanced Recall: Allows AI agents to search by meaning, context, and relationships (people, dates, events, concepts), leading to richer and more accurate recall than keyword-based search.
• Pipeline: Involves classification, chunking, and graph creation.
• Querying: Supports natural language queries like "what did we decide about project X last month?" or "show me all documents about topic Y."
• Benefits:
  • Memory and Context Awareness: Gives AI systems memory and context.
  • Continuity: Reduces hallucinations and boosts reliability.
• Target Audience: Developers, researchers, and teams building long-term AI assistants, knowledge-based tools, or document-driven workflows.

Project 6: Zappy (Automatic API Discovery)

Zappy is an open-source MIT-licensed Python library from Adopt AAI that automates API discovery for AI agents. It observes web application usage and converts API calls into structured, ready-to-use tools.

Key Points:

• Mechanism:
  • Runs browser sessions using Playwright.
  • Captures network traffic.
  • Filters traffic to extract API-relevant calls.
  • Exports these calls as HAR logs or tool definitions.
• Tool Conversion: Supports converting discovered APIs into agent-friendly tools for frameworks like Langchain, including type-safe schemas and optional custom headers.
• Credential Handling: Manages encryption (AES 256 GCM) and secure loading of API keys for services like OpenAI, Anthropic, and Google.
• Benefits:
  • Automation: Replaces a brittle manual process with an automated, reproducible one.
  • Efficiency: Speeds up the building of real-world AI integrations.
  • Control and Visibility: Provides full control and visibility over API integration.
• Use Cases: Developers, AI tool builders, and teams building agentic workflows that require reliable backend API calls.

Project 7: Uptime Kit (Uptime Monitor)

Uptime Kit is a free, MIT-licensed, open-source uptime monitoring solution that can be run locally or on a server. It provides a simple, self-hosted tool to monitor the availability of services.

Key Points:

• Functionality: Monitors websites, APIs, or servers at regular intervals (e.g., every minute).
• Monitor Types: Supports HTTPS, DNS, Incip, and Ping.
• Real-time Dashboard: Offers a web UI with:
  • Response time charts.
  • Status history.
  • Colored status indicators (Green: operational, Yellow: degraded, Red: down).
• Deployment: Easy setup via Docker, with a frontend and backend connecting to SQLite.
• Benefits:
  • Self-Hosted: Provides full control and no vendor lock-in.
  • Peace of Mind: Downtime alerts and logs are kept locally.
• Target Audience: Developers, CIS admins, site owners, and hobbyists running web services.

Project 8: Agent SOP (Standard Operating Procedures)

Agent SOP is an open-source project (Apache 2.0 license) that defines a standardized markdown-based format for AI agent workflows, called SOPs (Standard Operating Procedures).

Key Points:

• Format: Uses plain markdown to describe complex, multi-step workflows.
• Structure: SOPs include:
  • Parameters: Input variables for the workflow.
  • Overview/Objective: A clear description of the goal.
  • Step-by-Step Instructions: Uses RFC 2119 keywords (e.g., MUST, SHOULD, MAY) to provide structured constraints and guidance to the agent.
• Benefits:
  • Reliability and Repeatability: Combines the reliability of scripted workflows with the flexibility of LLMs.
  • Human Readability: Workflows are easy to understand and share.
  • Enforced Structure: Ensures agents behave consistently.
• Use Cases: Developers, AI tool builders, researchers, and teams deploying automation pipelines who need clarity, control, and repeatability in agent workflows.

Project 9: Blueprint MCP (Autogenerate Architecture Diagrams)

Blueprint MCP is an open-source Python tool by Arcade AI that automatically generates architecture diagrams from codebases. It visualizes system structure, modules, data paths, and function flows.

Key Points:

• Functionality: Analyzes project source code to create professional architecture diagrams.
• Process:
  • Install the CLI and log into the Arcade platform.
  • Trigger diagram generation using methods like start_diagram_job.
  • Download the resulting diagram (PNG or base64 encoded image).
• Visualization: Maps out modules and interactions within a project, turning complex code into understandable flowcharts or architecture maps.
• Integration: Works with other Arcade MCP ecosystem components to visualize API flows, authentication paths, or cross-service data pipelines for projects using cloud services (e.g., Google Drive, GitHub).
• Benefits:
  • Clarity and Documentation: Provides instant clarity and documentation for complex codebases.
  • Time Saving: Saves hours of code review and onboarding effort.
• Target Audience: Architects, dev leads, and solo developers who need to understand and document system structure.

Project 10: Agent Sandbox Skill

Agent Sandbox Skill provides isolated sandbox environments for AI agents to safely execute code and experiments. It uses E2B sandboxes to prevent agents from harming the host machine.

Key Points:

• Isolation: Creates secure, isolated environments for agents.
• Capabilities: Agents can safely run commands, build full-stack applications, install packages, and perform browser automation.
• Full Stack Development: Supports scaffolding front-end and back-end projects (e.g., Vue + FastAPI + SQLite), running build/test cycles, and browser automation (e.g., with Playwright).
• Lifecycle Management: Manages sandbox isolation of file systems and network access per agent fork, allowing for multiple independent agent sessions.
• Benefits:
  • Safety: Prevents accidental file corruption or unwanted network access.
  • Reproducibility: Ensures consistent and repeatable experiments.
  • Scalability: Allows for running numerous independent agent sessions.
• Target Audience: Developers, AI tool builders, and teams delegating engineering tasks to AI agents who require control, safety, and reproducibility.

Synthesis/Conclusion

This video showcases ten powerful open-source GitHub projects designed to enhance AI development workflows. From improving LLM response quality with LLM Council and enabling efficient tool integration via Code Mode, to providing robust agent development frameworks like ADK Go, these tools address critical aspects of building and deploying AI. The projects also focus on enhancing AI memory and context with Memory and Cognet, automating API discovery with Zappy, ensuring service reliability with Uptime Kit, standardizing agent workflows with Agent SOP, visualizing code architecture with Blueprint MCP, and ensuring safe AI coding experiments with Agent Sandbox Skill. Collectively, these tools offer developers and researchers advanced capabilities to build more intelligent, reliable, and efficient AI applications.