Projects sharing features with Agentos

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

Sandcastle is a TypeScript library for launching AI coding agents from scripts or CI pipelines and running them unattended inside isolated sandboxes. A single programmatic call starts a chosen agent, runs it for a set number of iterations, and returns the commits, branch, and per-iteration results. Sandboxes can be Docker or Podman containers, native operating-system sandboxes (Bubblewrap on Linux, Seatbelt on macOS, with no image or daemon), or cloud providers such as E2B, Modal, and Fly.io Sprites. Agents can also run directly on the host with no isolation. The agent and sandbox layers are

container-use is a containerized AI execution environment and code sandbox designed to provide a secure space for AI coding agents to execute commands and build applications. It functions as a workspace orchestrator that provisions isolated containers mapped to git branches, allowing multiple agents to operate in parallel without state conflicts or affecting the host system. The project serves as a Model Context Protocol server, bridging AI agents to containerized environments for standardized tool access. It enables a workflow for reviewing and merging changes made by agents within these iso

CubeSandbox is a Kubernetes-based platform for executing AI agents in secure, lightweight environments. It provides a code execution sandbox that uses hardware isolation and dedicated guest kernels to run untrusted code without risking the host system. The project features a network egress firewall that restricts outbound communication via domain allowlists and audit logging. It also includes a container snapshotting manager capable of capturing the runtime memory and disk state of environments to enable instant cloning and recovery. The platform covers cluster orchestration through a web-ba

This project is a polyglot runtime bridge and interop framework designed to execute .NET and Node.js code within a single operating system process. It functions as a cross-runtime execution engine and in-process scripting host, enabling bidirectional communication and data exchange between the Common Language Runtime and JavaScript environments to eliminate cross-process communication overhead. The framework distinguishes itself by providing a system for bidirectional asynchronous callbacks and automatic data marshalling of binary buffers and serializable values between different managed obje

rCore is a Rust-based operating system kernel and microkernel designed for Linux compatibility. It functions as a self-hosted development kit that implements a system call interface to support the execution of standard Linux userspace applications. The system is designed for modularity, featuring a mechanism for loading and integrating kernel modules into the active environment without requiring a system reboot. The kernel provides core operating system capabilities, including virtual memory mapping for process isolation, a disk-based file system for data persistence, and a layered network p

Tengo is a dynamic, embeddable scripting language for Go applications that allows for the execution of custom scripts without requiring the host binary to be recompiled. It operates as a bytecode-compiled virtual machine, transforming source code into a compact intermediate representation for execution on a stack-based engine. The system is designed as a secure scripting sandbox, enforcing strict limits on memory allocation and execution time to safely run untrusted code. It supports concurrent script execution by cloning compiled bytecode and using recursive immutability conversion to share

ammo.js is a JavaScript port of the Bullet physics engine, compiled via Emscripten to provide a high-performance physics library for the browser. It functions as a 3D rigid body engine and an Emscripten compiled library that enables complex physical computations using WebAssembly and JavaScript. The project provides specialized simulation capabilities for soft body physics, modeling the deformation of flexible materials like cloth and rubber, and a vehicle dynamics engine for calculating the mechanics of wheeled vehicles. The simulation surface also covers rigid body dynamics for non-deforma

TIC-80 is a fantasy console platform and multi-language game engine that provides a virtual retro game development environment. It operates via a bytecode virtual machine that executes game logic within fixed memory and resolution constraints. The project distinguishes itself by offering integrated asset editors for pixel art, tile maps, and a pattern-based chiptune audio workstation all within a single environment. It supports multi-language scripting, allowing developers to write logic in Lua, JavaScript, or Ruby, and provides a standalone game exporter to package projects into native execu

Isolate is a low-level sandbox designed to execute untrusted programs within a strictly controlled environment. It functions as a process isolation engine that prevents potentially harmful code from interacting with or damaging the host operating system. The tool leverages Linux kernel primitives, including namespaces and control groups, to partition system resources and enforce hardware usage boundaries. By applying filesystem virtualization and system call filtering, it restricts the visibility and interaction of a process with the host, ensuring that untrusted applications operate only wit

This project is a secure container runtime that provides strong isolation for application workloads by implementing a userspace kernel. By intercepting system calls and executing them within a memory-safe, restricted environment, it minimizes the attack surface exposed to the host kernel. It functions as a drop-in engine for standard container orchestration platforms, ensuring compatibility with industry-standard runtime specifications while maintaining a hardened execution boundary. The runtime distinguishes itself through its ability to virtualize core system resources, including an indepen

E2B is a cloud-based infrastructure platform designed to provide secure, isolated execution environments for code and shell commands. It functions as an ephemeral orchestrator that provisions lightweight virtual machines, allowing developers and autonomous agents to run untrusted processes within a sandbox that is completely separated from the host system. The platform distinguishes itself through its focus on programmable, serverless workspaces that support the full lifecycle of cloud-based development. By utilizing hardware-level isolation and snapshot-based resumption, it enables the near-

Lucet is a WebAssembly runtime and sandboxing compiler that translates WebAssembly bytecode into native machine code. It serves as a secure execution environment and native code generator designed to run untrusted code while preventing unauthorized access to host system resources. The project focuses on high-performance sandboxing by using ahead-of-time compilation to achieve near-native execution speeds. It implements software-based fault isolation and a host-call interface to manage secure communication and data exchange between the isolated module and the external host application. The sy

Hyperlight is an embedded virtual machine manager designed to execute guest binaries within hardware-isolated code sandboxes. It utilizes a KVM micro-VM manager to run untrusted third-party code, enforcing strict memory boundaries to prevent unauthorized host access. The project features a guest-host function bridge that facilitates bidirectional communication and a state snapshot tool for saving and restoring the memory state of a sandbox to reduce startup latency. The system includes a toolchain for guest binary cross-compilation and mechanisms for managing resource constraints, such as fi

Rhai is an embedded scripting engine and dynamically typed language designed for integration into Rust applications. It functions as an abstract syntax tree compiler and native interop layer, allowing developers to map Rust types and functions into a scripting environment for bidirectional communication. The project serves as a framework for creating customizable domain-specific languages. It allows for the definition of custom operators, syntax, and restricted execution environments, enabling the creation of specialized languages with tailored functional sets. The engine covers a broad rang

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

CodexGuide is a documentation website and learning resource for the Codex AI coding assistant. It walks newcomers through an ordered reading path: installing, signing in, subscribing, configuring, and running a first low-risk task. The path then continues toward team use. It also helps readers compare the desktop app, command line, cloud, IDE, and chat entry points so they can choose the one that fits their workflow. The guide is built around practical, checkable work. Its task recipes are copyable templates with defined inputs, outputs, and verification steps. They cover coding tasks such as

This repository is a static analysis of the Claude Code terminal coding assistant, based on a reading of its TypeScript source. It documents how the agent is built, from its startup path and a single shared execution core to the streaming tool-call loop, sub-agents, and terminal interface layers. It is a reference and study resource about the agent rather than the agent itself. The analysis centers on a few areas. One is the shared core that routes queries, sub-agents, tools, and permission checks through the same control flow. Another is memory: layered, file-based records that users can ins

mcp-context-forge is a Model Context Protocol federation gateway that unifies diverse AI tool servers and APIs into a single consistent interface for discovery and execution. It acts as a centralized proxy that aggregates multiple servers and APIs, allowing AI agents to access and invoke a unified set of tools, prompts, and resources. The project distinguishes itself through a multi-protocol translation bridge that converts communication between standard I/O, SSE, gRPC, and REST to enable interoperability between disparate tool servers. It includes a comprehensive LLM evaluation framework for

KiroCrew is a persistent workspace for AI-assisted development built around an autonomous coding agent. Tasks are planned, carried out, checked against the spec, and retried on failure, with state saved to checkpoints so long-running work can resume after a restart. One shared runtime serves the desktop app, web dashboard, command line, and chat channels such as Slack and Discord, so the same ongoing work is visible from each of them. The agent improves with use: user corrections and task failures are turned into lasting lessons, applied globally or limited to a single repository, and repeate

Fragments is an open-source AI code generation sandbox that produces code automatically based on user prompts and executes it inside isolated cloud environments. The project provides a secure foundation for running AI-generated code by sandboxing execution away from the host system, preventing potential harm while allowing users to see results immediately. The sandbox supports customization through configurable execution environments defined via Dockerfiles, enabling code to run in specific runtimes or frameworks. Users can integrate different language models and model providers by registerin

DeepSeek-TUI is an AI coding agent orchestrator and framework designed to automate complex programming tasks. It functions as a harness for coordinating AI models that can read source code, edit files, and execute shell commands through automated agent workflows. The system is distinguished by its multi-agent coordination capabilities, which allow for the spawning of parallel sub-agents to handle concurrent investigations or implementation slices. It employs autonomous goal-seeking loops to pursue objectives across multiple turns and utilizes a tool integration gateway to connect models to ex

NemoClaw is an LLM agent orchestrator and sandboxed execution environment designed to deploy and manage the lifecycles of large language model agents. It provides a secure runtime that isolates persistent agents from the underlying host system to ensure operational security. The system includes a secure LLM inference gateway that acts as a managed routing layer, securing communication between AI agents and inference engines to prevent unauthorized access. It also integrates with NVIDIA OpenShell to run specialized agents within a secure shell environment. Operational control is provided thro

CodeWhale is an AI coding agent orchestrator and development harness designed to coordinate autonomous agents that read, edit, and verify code. It provides a secure environment for AI agents to perform multi-step software engineering tasks, utilizing a sandboxed execution model to isolate shell commands and protect the host system. The system distinguishes itself by spawning multiple independent agents in parallel to handle separate investigation or implementation slices simultaneously. It employs a multi-model gateway to route requests across various cloud APIs and local servers, and utilize

vibesdk is an agentic software development platform and framework designed to coordinate autonomous agents that write, debug, and refine full-stack applications from natural language. It serves as a cloud-native application orchestrator and an LLM-powered code generation framework that converts prompts into functional code through iterative conversations and multi-phase agent behaviors. The project distinguishes itself by providing a complete toolchain for building AI development platforms. This includes the ability to integrate various model providers, construct custom LLM toolkits, and mana

Moltworker is an AI agent sandbox and model orchestrator designed for the secure execution of untrusted code and shell commands generated by large language models. It functions as a gateway proxy that routes requests to multiple AI providers through a unified interface, integrating a container runtime backed by S3-compatible object storage to persist state across ephemeral lifecycles. The system distinguishes itself by combining an AI model orchestrator with a headless browser controller for automated web scraping and screenshot capture. It manages the full lifecycle of AI agents, including m

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