Projects sharing features with Antigravity Sdk Python

Hermes-webui is a self-hosted AI orchestrator and web interface for managing autonomous agents. It serves as a multi-provider gateway that connects cloud and local large language models, providing a central hub to execute scheduled background jobs, run shell commands, and manage agent memory on private hardware. The system distinguishes itself through a persistent memory manager that utilizes knowledge graphs and markdown files for long-term context across sessions. It features a model context protocol host for extending agent capabilities with standardized tools and supports the orchestratio

This project is an educational curriculum and architectural framework for building autonomous AI agents and multi-agent systems. It provides a structured learning path focused on the development of independent software components capable of planning, executing tasks, and utilizing external tools to achieve high-level goals. The framework emphasizes multi-agent system orchestration through distributed architectures where specialized agents collaborate using standardized communication protocols. It details specific design patterns such as dual-memory systems for maintaining short-term plans and

Omnigent is a policy-governed orchestrator for coding agents. It runs several agent harnesses, such as Claude Code and Codex, together in one session, and a single harness identifier decides which agent handles a session, so teams can swap agents without rewriting their definitions. Sub-agents can each use their own harness, model, prompt, and sandbox inheritance, which lets one agent review another's work or split a task with it. Every agent action passes through layered policies set at the server, agent, and session levels. Each policy function allows, denies, or abstains, and a denial stop

WeKnora is a multi-tenant retrieval-augmented generation (RAG) knowledge platform and autonomous AI agent framework. It transforms raw documents into queryable knowledge bases and integrates large language models with vector databases to provide grounded AI responses. The system also functions as a Model Context Protocol (MCP) tool server, exposing knowledge search and agentic capabilities to external AI clients. The platform distinguishes itself through an autonomous agent framework that utilizes iterative reasoning, tool calling, and web search to solve multi-step tasks. It implements a sta

Deepagents is an LLM agent orchestration platform and stateful application server designed for deploying and managing AI agents built with computational graphs. It provides a containerized runtime environment that handles agent execution, state persistence, and the versioning of AI assistants. The platform distinguishes itself through deep integration with the Model Context Protocol, allowing agents to function as servers that expose tools and capabilities to external clients. It features a sophisticated observability suite for capturing execution traces, performing LLM-based evaluations agai

This repository is a long-form technical book about how a production AI coding agent runtime, often called an agent harness, is built. It dissects a real-world coding agent's architecture chapter by chapter and turns it into transferable lessons, and it also works as a step-by-step guide to designing and building your own harness around a language model. Python scripts in the repository support the book itself rather than the agent. The book's core subject is the machinery around the model: a streaming conversation loop that repeats tool calls until the model returns plain text, a tool protoc

This project is a Python framework for building autonomous, event-driven agent systems. It provides a unified runtime for orchestrating multi-agent workflows, managing persistent conversation state, and executing code within secure, isolated sandbox environments. The framework is designed to handle complex task delegation, allowing agents to invoke other agents as tools while maintaining context across multi-turn interactions. The framework distinguishes itself through its deep integration with the Model Context Protocol, enabling agents to connect to external data sources and remote services

This project is an AI-powered IDE extension and LLM coding assistant that provides a conversational interface for generating, refactoring, and debugging code. It functions as an AI agent framework and a Model Context Protocol client, connecting AI models to external data sources and tools to automate complex development tasks. The system is distinguished by its use of autonomous AI agents capable of multi-step task execution, including the ability to read files, modify code, and run terminal commands iteratively. It supports recursive agent orchestration through subagent delegation and employ

Claude Code is a command-line interface and multi-agent orchestration framework designed for autonomous software engineering. It enables AI agents to perform codebase modifications, debugging, and Git workflow management while coordinating multiple specialized agents to decompose and execute complex engineering tasks in parallel. The system distinguishes itself through a high degree of isolation and safety, utilizing Git worktrees to create independent working directories for concurrent agents and implementing a tiered permission system that combines user rules, project policies, and OS-level

gptme is an autonomous AI agent server and framework designed for local system automation, software development, and code execution. It operates as a local execution engine that enables language models to run shell commands, modify local files, and interact with the operating system. The project functions as a Model Context Protocol client, integrating with external servers to expand agent capabilities with standardized tools and data sources. It features a provider-agnostic routing system to orchestrate tasks across multiple proprietary cloud APIs and local AI backends. The system includes

OpenBot is a self-hosted workspace where teams run AI bots as coworkers. Each bot gets its own isolated computer with a browser, workspace files and tools. Agents from any framework can be connected over the AG-UI protocol, and built-in bots can run alongside them. People converse with bots one-to-one or in groups, watch the bot's screen and the commands it runs, and can take over the browser when an agent hits a login wall or a two-factor prompt. Governance is central to the project. Every browser, file and tool action passes through a policy gateway that checks permissions and writes an aud

pi-web is a self-hosted web interface for running and reviewing sessions with an AI coding agent from the browser. Coding-agent sessions run on a server against local project folders and Git worktrees. Replies and tool calls stream into a chat window as they happen, and conversations can be branched, forked, or compacted as the work continues. Sessions are organized by project and Git worktree. Checkouts of the same repository are grouped together, and each session remembers the directory it started in. Sessions can be resumed, renamed, pinned, archived, exported, and deleted. Past conversati

Eino is an AI agent development kit and LLM application framework designed for building autonomous agents and orchestrating complex language model workflows. It serves as a multi-agent orchestration engine and workflow orchestrator, providing a graph-based execution model to route data between models, tools, and retrievers. The framework distinguishes itself through a robust set of multi-agent coordination patterns, including supervisor-led management, sequential flows, and autonomous reasoning loops like ReAct. It features advanced agent execution controls such as active turn preemption, che

Yao is an LLM agent framework and low-code web app builder designed for orchestrating autonomous AI agents. It provides a platform to design, deploy, and coordinate agents with specialized personas that can plan tasks, utilize external tools, and execute multi-stage pipelines. The project distinguishes itself through a Model Context Protocol server for connecting assistants to external binaries and HTTP services, and a gRPC remote execution engine that allows agents to manage remote servers and devices. It includes a model-agnostic provider bridge that supports dynamic switching between vario

Switch is a self-hosted platform where people and AI agents share chat rooms. Agents built on different coding-agent harnesses, models or providers can join a room as teammates, and the system runs and coordinates their sessions on a laptop, over SSH, or on remote machines. Rooms can be bridged to channels on Slack, Microsoft Teams, Discord, Telegram and Mattermost, so teammates address agents in the tools they already use. Agent sessions are launched through native SDK or protocol adapters, with providers such as Claude Code, Codex, Cursor and OpenCode driven through one shared session inter

Agency Swarm is a multi-agent orchestration framework and development kit designed to coordinate specialized AI agents through defined communication patterns and handoffs. It functions as a system for managing agent swarms, providing an API gateway to expose these coordinated collectives as production-ready HTTP endpoints. The project distinguishes itself through its Model Context Protocol integration layer, which connects agents to external data sources and capabilities. It implements specialized orchestration patterns, such as the orchestrator-worker model and role-based delegation, to tran

The agent-governance-toolkit is a framework for enforcing security policies, managing zero-trust identities, and sandboxing the execution of autonomous AI agents. It provides a governance layer designed to control the behavior of agents through the use of a security policy engine, cryptographic identity management, and a runtime execution sandbox. The project distinguishes itself through a multi-tier privilege ring system and a cryptographic identity mesh that secures communication between autonomous entities. It implements a decay-based trust scoring mechanism to track entity reliability and

ZenML is an extensible machine learning orchestration framework designed to manage the end-to-end lifecycle of data pipelines and AI agent workflows. It functions as a durable orchestrator that executes machine learning tasks as directed acyclic graphs, ensuring that every step is containerized for consistent performance across local, cloud, and hybrid infrastructure. By decoupling pipeline code from underlying compute and storage backends, the platform allows developers to define infrastructure-agnostic stacks that remain portable across diverse environments. The project distinguishes itself

ZenML is an orchestration platform designed for building, deploying, and monitoring reproducible machine learning pipelines and agentic workflows. It provides a unified framework that manages the entire lifecycle of machine learning assets, from data processing and model training to the deployment of persistent inference services. By decoupling pipeline logic from underlying compute and storage, the platform enables teams to transition workflows seamlessly from local development environments to production-grade cloud infrastructure. The platform distinguishes itself through a service-oriented

This project provides a TypeScript software development kit for the Model Context Protocol, a standard designed to facilitate bidirectional communication between AI applications and external data sources or tools. It serves as a foundational framework for building both clients and servers, enabling language models to interact with external systems through a unified, decoupled interface. The SDK distinguishes itself by implementing a transport-agnostic connection layer that supports both local standard input-output streams and remote HTTP endpoints. It utilizes a JSON-RPC message bus to manage

Clawith is a self-hosted, multi-agent AI platform for running a team of persistent language-model agents inside an organization. Each agent keeps its own identity, long-term memory, and sandboxed workspace, and the agents work with each other and with human colleagues rather than acting as one-off chatbots. Agents can act on their own through schedules, polling checks, incoming messages, and webhooks, and they create and adjust their own triggers without waiting for a person to give commands. What sets it apart is the "digital employee" approach: agents are onboarded like new hires, with acce

Atmosphere is a Java-based framework for building and coordinating AI agents. It provides a real-time transport layer for streaming data via WebSockets, SSE, gRPC, and WebTransport, alongside a multi-agent orchestration framework for managing agent fleets through sequential, parallel, and graph-based execution workflows. The project features a durable workflow engine that persists agent state as snapshots, allowing long-running tasks to survive system restarts and incorporate human-in-the-loop approvals. It also implements Model Context Protocol servers to expose tools, resources, and prompt

Claude Agent SDK is a Python library from Anthropic for building AI agents that use Claude’s tool‑calling, streaming, and session‑management capabilities. It provides a structured framework for intercepting and logging every tool call an agent makes, managing conversation sessions across multiple turns, and controlling which tools the agent is allowed to invoke through configurable permission rules. The SDK distinguishes itself with middleware‑driven tool interception that lets developers block, modify, or require approval for tool calls before or after execution. A permission policy engine e

Edict is a multi-agent orchestration system and framework designed to coordinate specialized large language model agents. It functions as a workflow designer and orchestrator that decomposes complex objectives into structured plans, using directed acyclic graphs and role-based hierarchies to execute sub-tasks. The system is distinguished by its event-driven architecture, utilizing a publish-subscribe event bus and transactional outbox to manage agent communications and task transitions. It features a dedicated skill management system that allows for the importation, updating, and sandboxed ex

GLM-4.5 is a multimodal large language model and advanced reasoning system. It functions as an AI coding assistant, an autonomous AI agent, and a multimodal content generator capable of processing and generating text, images, audio, and video within a single unified system. The project is distinguished by its deep reasoning capabilities, utilizing chain-of-thought processing to solve complex mathematical, logical, and technical problems. It features an agentic architecture that allows for autonomous task execution, long-horizon goal planning, and the ability to interact with external tools an

Rea is a reverse engineering toolkit that lets AI agents analyze software through a local Model Context Protocol server. An agent can investigate how an application works, from observed behavior and web traffic down to native binaries, and return findings with supporting evidence and stated limitations. All analysis runs on the user's own machine, so the inspected software is not uploaded and only tool results are passed to the agent. For native code, Rea drives an installed disassembler or decompiler such as Hopper, Ghidra, IDA, or Kuna to produce pseudocode, assembly, strings, symbols, and