Daily AI Insight
数据源洞察报告

免责声明

本站内容由 AI 自动聚合、分析与生成,仅供信息参考与学习交流,不构成投资、法律、医疗或其他重大决策建议。请结合原始信源独立判断,作者不对因使用本站内容而产生的任何后果承担责任。

关于本项目

个人开源实验项目,由 @sqliang 构建与维护。

在 GitHub 查看源码

© 2026 Daily AI Insight Engine · Built with AI-assisted pipelines

数据源列表

GitHub Trending

Tier B社区讨论ENscrape2026-10-10

GitHub 每日热门开源仓库,过滤 AI/LLM/Agent/MCP 相关项目。追踪开发者社区关注的开源基础设施与框架变化,是技术选型的重要参考。

AILLMagentmodelRAG+5
https://github.com/trending
184 篇文章101 篇深度分析83 篇待处理生成于 2026-10-10 09:30 UTC

文章列表

184 篇2000-01-01 ~ 2026-10-14
Scout·清单github.com

morluto/rea

Reverse engineer anything with agents, from app behavior down to native binaries.https://rea.tools English · 简体中文 · 繁體中文 · 日本語 · 한국어 · Türkçe · Русский · Tiếng Việt · ไทย · Deutsch · Español · Français · Українська · Polski · Português (Brasil) · العربية · فارسی REA: Reverse Engineer Anything One MCP for reverse engineering across binaries, applications, and runtime behavior. See a feature you like. Understand how it works, down to the binary level. Website · Guides · Showcases Quick start · How REA works · What you can analyze · Showcases · FAQ · Documentation npx rea-agents setup Join the Reverse Engineering Community Discord · Q&A · Show and Tell See a feature in an app that you want in your own product? Ask your agent to investigate it with REA. It can inspect the app without its source code, explain how the feature works, show the evidence, and build a version for your project. REA connects your agent to tools for inspecting native binaries, JavaScript and Electron apps, .NET assemblies, and websites. You can also use the same tools from your terminal. Analysis runs locally, and results include the evidence and limitations behind each conclusion. Setup registers REA with your agent and installs matching workflow instructions. Native analysis can use an existing Hopper, Ghidra, or IDA installation; setup can optionally install Hopper with approval. Static JavaScript analysis needs no native analysis engine. Visit the REA website for setup instructions, illustrated guides, and real case studies. Quick start Set up your agent With Node.js and npm installed, run: npx rea-agents setup Choose your agents, review the proposed changes, and approve them. Setup adds REA's MCP server and matching workflow instructions, with backups of existing configuration. Restart your agent afterward. Setup supports Claude Code, Codex, Cursor, Gemini CLI, Grok Build and other agents. See installation and setup for provider configuration and manual MCP registration. Ask your agent Understand how search works in the Notes app, show me the evidence, and build a similar feature for my project. Replace Notes with your target app and the feature you want to understand. Use the terminal Inspect an extracted JavaScript/Electron app directory or ASAR: npx -y rea-agents@latest analyze-javascript-application /absolute/path/to/app --json The result includes modules, imports, Electron boundaries and their evidence. Replace the path with your target, such as "D:/apps/example" on Windows. To install the rea command for regular use: npm install --global rea-agents rea --help For native analysis, configure a provider first. See the CLI and Evidence guide for native commands, provider selection, snapshots and scripting. Update REA REA changes quickly, and new releases include frequent bug fixes. Keep your installation up to date. For an npm-installed CLI: rea update To refresh your agent registrations and skill, run the setup command printed by the update. If you use npx, update your agent setup with: npx rea-agents@latest setup Review the setup changes and restart your agent. For one-off CLI commands, use npx rea-agents@latest followed by the command. How REA works Your agent calls REA through MCP to inspect the target and trace relevant code. REA returns findings with their evidence. The agent uses them to ask follow-up questions, explain the behavior, or write and test an implementation. CLI commands use the same workflows. Open the full-size figure. What you can analyze REA requires Node.js 22.x (>=22.19), 24.x (>=24.11), or 26+, plus npm. Additional tools and host support depend on the target: Target What REA returns Requirements and guide Native binaries Pseudocode, assembly, strings, symbols, calls and references Hopper, Ghidra or IDA; native analysis Offline ELF layout Sections, segments, original symbols/relocations and static mitigation candidates Caller-supplied pwntools on Linux x64; binary diagnostics EVM bytecode Dispatch selectors, byte offsets, inferred arguments and mutability Local raw/hex carrier; offline EVM guide Recorded Linux crashes Raw notes, every recorded thread's registers/signals and optional mapping candidates Caller-supplied pwntools; optional GDB/pwndbg; recorded crashes JavaScript / Electron Modules, imports, source maps, routes, IPC and native add-on relationships Node.js and npm; application analysis Websites Page structure, scripts, network observations and requested screenshots A Chrome-family browser; browser analysis Saved network captures Requests, responses, exposed payloads and source locations HAR; mitmdump on Linux for native mitmproxy captures; capture guide .NET assemblies Metadata, CIL instructions, declared native dependencies and build comparisons None (static only); managed-code guide Android APKs Manifest declarations, classes, decompiled methods and references Headless JADX and a full JDK on Linux/macOS/Windows x64; Android guide Firmware Regions, extraction results and native-analysis handoffs Binwalk / Unblob on Linux; firmware guide Packages and resources File inventories, digests, plists, Apple bundle anatomy and extracted resources Artifact and JavaScript guide, Apple applications Process behavior Terminal output, interactions, exit and filesystem observations, and run comparisons Linux/macOS with a native PTY; process capture Static JavaScript and .NET inspection read the supplied files without running the application. Runtime capture runs or interacts with the selected target using your user permissions; each runtime guide describes its effects. Native formats and host support vary by provider. See Hopper and Ghidra setup, the IDA guide, and experimental Windows Ghidra support. Ghidra also supports 16-bit DOS analysis. For large binaries, raise its startup deadline with REA_GHIDRA_STARTUP_TIMEOUT_MS. For provider selection, see the CLI guide. Check release availability for features added since the latest npm release. Showcases DX-Ball: reconstruct a sound-pan calculation Follow a sound call into its position-to-pan helper, inspect the instructions, and turn incomplete pseudocode into C. The reconstruction passes 3,205 original-x86 cases and reproduces all 63 compiled function bytes. Read the case study · Reconstruction repository Notion: trace the Electron clipboard bridge Find the renderer's clipboard API, follow it through preload and IPC into the main process, and inspect the rich clipboard format. Read the case study TH04: recover a DOS bullet-ring calculation Inspect the original PC-98 game's 16-bit instructions, recover the fixed and aimed angle calculations, and compare the reconstructed C++ with the historical compiler output. Read the case study · Reconstruction repository If you've used REA on something interesting, we'd love to see it. Share your case in an issue or a pull request, including the target, your question, how REA helped, and what you found. FAQ Which agents can use REA? Any agent that supports local MCP servers. Setup configures the supported agents; other clients can use manual MCP registration. Do I need Hopper, Ghidra or IDA? Deep native analysis uses one of them. Static JavaScript and .NET inspection work without a native analysis engine. Setup can install Hopper after approval; Ghidra and IDA use your existing installations. See provider setup. Do I need to start Hopper first? REA starts Hopper when an operation needs it. On macOS, a first-run dialog may ask you to choose demo mode or activate your license. See Hopper startup and troubleshooting. What does installing the skill from skills.sh do? The skill supplies investigation instructions for your agent. Use npx rea-agents setup to register REA's MCP server and install the matching instructions, then restart your agent. See skill-only installation. What code does REA return? Native analysis returns pseudocode and assembly. JavaScript/Electron analysis recovers modules and their relationships. Your agent uses these findings to write and test an implementation; the showcases give worked examples. Does REA upload my app? REA analyzes targets locally. Your agent receives the tool results, and its model provider has its own data policy. What should I do if I hit a bug? Update first; a recent release may already fix it. For an npm-installed CLI: rea update For agent setup through npx: npx rea-agents@latest setup If you're using an agent, complete the setup refresh and restart it. Retry the same task. If the problem persists, open an issue with your REA version, target type, steps to reproduce and error output. Documentation Start with the website's worked guides. For exact options, prerequisites and result contracts: Installation and setup: agent registration, provider configuration, updates and uninstall. Readiness and troubleshooting: diagnose one agent or analysis engine. CLI and Evidence: commands, provider selection, snapshots, import/export and exit statuses. MCP contracts and agent prompts: tool results, sessions and guided investigations. Tool catalog: generated inventory of tools, providers and CLI commands. Roadmap: planned work and capability trackers. Report vulnerabilities through SECURITY.md. Star history 🎉 50,000 GitHub stars — thank you! Thanks to everyone using REA, reporting bugs, requesting features, testing builds, and contributing fixes. Disclaimer REA provides tools for lawful reverse-engineering research, analysis, and reconstruction. You are responsible for obtaining any required authorization and complying with applicable laws. The project does not endorse illegal or unauthorized use. REA is an open-source software project. We have not issued or endorsed any cryptocurrency or token. Tokens using the REA name are not affiliated with the project. Contributing We'd love your help with REA! Open an issue to report a bug or suggest a feature, or send a pull request to improve the code or docs. See CONTRIBUTING.md for development setup and checks, testing for verification lanes, and the architecture map for the project structure. License MIT

no score查看详情
Analyzed·分析github.com

alibaba/open-code-review

阿里巴巴开源 AI 代码审查 CLI 工具 Open Code Review(ocr),源自其内部使用两年的 AI 代码审查助手,可读取 Git diff 并结合可配置 LLM 生成行级精确的审查评论。官方称其在同等模型下精度与 F1 显著高于通用 Agent,且仅消耗约 1/9 的 token。

阿里巴巴将内部运行两年的 AI 代码审查助手孵化并开源为 Open Code Review(命令名 ocr),该工具读取 Git diff,将变更文件交给具备工具调用能力的 LLM Agent,生成带行级定位的审查评论,并支持对无 diff 的整文件扫描。它采用确定性工程(精确文件选择、智能文件打包、细粒度规则匹配、独立定位与反思模块)与 Agent 动态决策相结合的分工架构,可通过 npm 全局安装。官方给出基于 50 个开源仓库、200 个真实 PR、10 种语言、80 余名资深工程师交叉验证、1505 条标注缺陷的基准,称其精度与 F1 高于通用 Agent 且 token 消耗约为其 1/9,但召回率较低,属有意取舍。项目以 Apache-2.0 协议发布,版权归 Alibaba 2026。

框架工具◆ 深度研判▲积极
6.0查看详情
Analyzed·分析github.com

anthropics/knowledge-work-plugins

Anthropic 开源了 11 个面向职能角色的 Claude 插件,专为 Claude Cowork 打造并兼容 Claude Code,覆盖销售、法务、财务、数据等工作。每个插件以 markdown 和 JSON 文件打包技能、MCP 连接器、斜杠命令与子智能体,开箱可用且可高度定制。

Anthropic 在 GitHub 上开源了 knowledge-work-plugins 仓库,发布 11 个面向职能角色的 Claude 插件,包括 productivity、sales、customer-support、product-management、marketing、legal、finance、data、enterprise-search、bio-research 与 cowork-plugin-management。这些插件专为 Claude Cowork 打造,同时兼容 Claude Code,每个插件打包了技能、MCP 连接器、斜杠命令与子智能体,并通过 MCP 服务器接入 Slack、Notion、Jira、Snowflake、HubSpot 等外部工具。插件完全由 markdown 和 JSON 文件构成,无代码、无基础设施、无构建步骤,用户可通过 claude plugin marketplace 与 claude plugin install 命令安装,并可替换连接器、注入公司上下文与流程进行定制。

框架工具◆ 策略投资▲积极
6.5查看详情
Analyzed·分析github.com

addyosmani/agent-skills

开发者 Addy Osmani 发布开源项目 addyosmani/agent-skills,为 AI 编程智能体提供生产级工程技能库,包含 25 个技能和 9 个覆盖开发全生命周期的斜杠命令,并可通过 npx skills CLI 安装到 70 多个智能体中。

开发者 Addy Osmani 在 GitHub 发布开源项目 addyosmani/agent-skills,包含 25 个技能(24 个生命周期技能加 using-agent-skills 元技能),覆盖 DEFINE、PLAN、BUILD、VERIFY、REVIEW、SHIP 六个开发阶段,并映射为 /spec、/plan、/build、/test、/review、/ship 等 9 个斜杠命令。项目通过 npx skills CLI 可安装到 Claude Code、Cursor、Gemini CLI、Codex、GitHub Copilot 等 70 多个智能体,同时提供各工具的原生插件集成方式。技能以纯 Markdown 编写,每个技能包含步骤、验证门禁和反合理化表格,覆盖编码、测试、代码审查、安全、性能与 Git 工作流等主题。

框架工具◆ 深度研判▲积极
5.5查看详情
Analyzed·分析github.com

storytold/artcraft

ArtCraft 在 GitHub 上发布,定位为面向艺术家的交互式 AI 图像与视频创作 IDE,支持在 2D 中构图、在 3D 中搭建场景并自选模型,称内置 62 个模型目录。

ArtCraft(GitHub 仓库 storytold/artcraft)发布了一款面向艺术家的 AI 创作 IDE,用户可下载安装或从源码构建。该工具支持在 2D 画布中构图、在 3D 中搭建与布景、调整角色身份与相机机位,并可在生成前先搭建场景,以提供精确可复现的结果。它整合了 Grok、Midjourney、Sora、World Labs 等多家提供方的图像、视频、音乐、3D 网格与世界模型,宣称拥有共 62 个模型的目录,并计划接入 Kling、Google、Runway、Luma 等更多提供方。

应用落地◆ 持续监测⇅混合
3.8查看详情
Analyzed·分析github.com

Robbyant/lingbot-map

开源项目 LingBot-Map 发布,这是一个面向流式三维重建的前馈式 3D 基础模型:通过几何上下文 Transformer 统一坐标锚定、稠密几何线索与长程漂移校正,并借助分页 KV 缓存注意力,在 518×378 分辨率下以约 20 FPS 稳定推理超过 10000 帧,在多项基准上优于现有流式与迭代优化方法。

Robbyant 团队在 GitHub 开源了 LingBot-Map,一个用于流式三维重建的前馈式 3D 基础模型,核心是几何上下文 Transformer,通过 anchor context、pose-reference window 与 trajectory memory 统一坐标接地、稠密几何线索和长程漂移校正。其推理采用带分页 KV 缓存的注意力机制,在 518×378 分辨率下可对超过 10000 帧的长序列保持约 20 FPS 的稳定推理。项目发布了 KITTI、Oxford Spires 等数据集上的评测脚本及室内、室外、LingBot-World、航拍等多段长视频 demo,并持续修复 FlashInfer 与 SDPA 的 KV 缓存缺陷。模型权重托管于 Hugging Face 与 ModelScope(robbyant/lingbot-map),并给出基于 PyTorch 2.8.0 + CUDA 12.8、FlashInfer 与 Kaolin 的安装与运行流程。

框架工具◆ 策略投资▲积极
5.5查看详情
Analyzed·分析github.com

twostraws/SwiftUI-Agent-Skill

Paul Hudson 发布开源项目 SwiftUI Pro,这是一个遵循 Agent Skills 格式的 agent 技能,用于指导 AI 编程助手编写更简洁、更现代的 SwiftUI 代码,覆盖 API 使用、设计、性能与无障碍等方面,可通过 npx 或 Claude Code 插件市场安装到 Claude Code、Codex、Gemini、Cursor 等工具中,采用 MIT 许可证。

知名 Swift 教程作者 Paul Hudson(Hacking with Swift 创始人)在 GitHub 上发布了开源项目 twostraws/SwiftUI-Agent-Skill,其核心是一个名为 SwiftUI Pro 的 agent 技能,基于其已有的 AGENTS.md 文件构建。该技能采用 Agent Skills 格式,针对 LLM 在 SwiftUI 开发中常犯的错误(如按钮对 VoiceOver 不可见、频繁使用已废弃 API、引发性能问题)提供检查与改进建议,覆盖导航、布局、动画、状态管理、VoiceOver、废弃 API 等主题。用户可通过 npx skills add 命令或 Claude Code 的插件市场命令安装到 Claude Code、Codex、Gemini、Cursor 等工具中,并支持以斜杠命令或自然语言触发。项目采用 MIT 许可证,允许商业使用、修改、分发与私人使用,并欢迎社区贡献。

框架工具◆ 持续监测▲积极
4.2查看详情
Analyzed·分析github.com

EpicGames/raddebugger

Epic Games 开源了 RAD Debugger,一款原生、用户态、多进程的图形化调试器,目前仅支持本地 Windows x64 与 PDB 调试,处于 ALPHA 阶段。项目还附带自定义的 RAD Debug Info(RDI)格式与专注巨型工程的高性能 RAD Linker。

Epic Games 发布了 RAD Debugger(仓库 EpicGames/raddebugger),这是一个原生、用户态、多进程的图形化调试器,当前仅支持本地 Windows x64 调试与 PDB 格式,且处于 ALPHA 阶段。项目同时推进两项相关技术:自定义调试信息格式 RAD Debug Info(RDI)以及用于生成 x64 PE/COFF 二进制的高性能 RAD Linker。RAD Linker 命令行兼容 MSVC,宣称在处理调试信息达数 GB 的超大工程时链接速度提升约 50%,启用大内存页可再提速约 25%。项目在 Windows x64 与 Linux x64 上开发,后续计划移植 Linux/DWARF 调试支持。

框架工具◆ 持续监测▲积极
4.0查看详情
Scout·清单github.com

liquidslr/system-design-notes

Notes of the book System Desgin Interview - An Insider's Guidehttps://pagefy-blush.vercel.app/system-design/system-design-interview-by-alex-xuSystem Design Interview - An Insider's Guide (Vol 1 and 2) These notes are based on the System Design Interview books - Vol 1 and Vol 2 2nd Ed Check the notes here: https://pagefy.io/system-design/system-design-interview-by-alex-xu Note: These notes are a work in progress. Chapter 1 - Scale From Zero To Millions Of Users Chapter 2 - Back-of-the-envelope Estimation Chapter 3 - A Framework For System Design Interviews Chapter 4 - Design A Rate Limiter Chapter 5 - Design Consistent Hashing Chapter 6 - Design A Key-Value Store Chapter 7 - Design A Unique ID Generator In Distributed Systems Chapter 8 - Design A URL Shortener Chapter 9 - Design A Web Crawler Chapter 10 - Design A Notification System Chapter 11 - Design A News Feed System Chapter 12 - Design A Chat System Chapter 13 - Design A Search Autocomplete System Chapter 14 - Design YouTube Chapter 15 - Design Google Drive Chapter 16 - Proximity Service Chapter 17 - Nearby Friends Chapter 18 - Design Google Maps Chapter 19 - Distributed Message Queue Chapter 20 - Metrics Monitoring and Alerting System Chapter 21 - Ad Click Event Aggregation Chapter 22 - Hotel Reservation System Chapter 23 - Distributed Email Service Chapter 24 - S3-like Object Storage Chapter 25 - Real-time Gaming Leaderboard Chapter 26 - Payment System Chapter 27 - Digital Wallet Chapter 28 - Stock Exchange Additonal Resources Rate Limiting Circuit Breaker Algorithm Uber Rate Limiter Consistent Hashing Consistent Hashing CS168: Introduction and Consistent Hashing: Apache Cassandra Scaling Discord Google Maglev Key-Value Store Amazon Dynamo Cassandra Architecture Google BigTable Architecture Amazon Dynamo DB Internals Design Patterns in Amazon Dynamo DB Internals of Amazon Dynamo DB Unique-ID Generator Ticket Servers: Distributed Unique Primary Keys on the Cheap Snowflake Web Crawler Web Crawling Google Dynamic Rendering Chat Systems How Discord stores billions of messages Flannel: An Application-Level Edge Cache to Make Slack Scale Search Autocomplete How We Built Prefixy Prefix Hash Tree Youtube YouTube Architecture YouTube scalability 2012 Transcoding Videos at Scale Facebook Video Broadcasting Netflix Video Encoding at Scale Netflix Shot based encoding Google Drive Differential Synchronization Differential Synchronization Video How We’ve Scaled Dropbox

no score查看详情
Analyzed·分析github.com

ayghri/i-have-adhd

ayghri/i-have-adhd 是一个面向编码助手的开源插件,通过 10 条规则强制 Claude Code 和 Codex 等工具以行动优先、简洁直接的方式输出,避免铺垫、客套话和冗余信息。

ayghri 在 GitHub 上发布了 i-have-adhd 插件,该插件为 Claude Code 和 Codex 等编码助手定义了 10 条输出规则,要求 AI 以行动先行、编号步骤、抑制离题、无开场白和结束语的方式回应。用户可通过插件市场命令安装,支持 Fork 仓库后编辑 SKILL.md 文件进行自定义。该项目基于《The Adult ADHD Tool Kit》一书改编,采用 MIT 许可证开源发布。

框架工具◆ 持续监测▲积极
3.5查看详情
Scout·清单github.com

manaflow-ai/cmux

Open source Ghostty-based macOS terminal with vertical tabs and notifications for AI coding agents. Built for multitasking, organization, and programmability.https://cmux.comcmux A Ghostty-based macOS terminal with vertical tabs and notifications for AI coding agents English | 日本語 | Tiếng Việt | 简体中文 | 繁體中文 | 한국어 | Deutsch | Español | Français | Italiano | Dansk | Polski | Русский | Bosanski | العربية | Norsk | Português (Brasil) | ไทย | Türkçe | ភាសាខ្មែរ | Українська ▶ Demo video · The Zen of cmux Docs · Blog · Changelog · Community Features Notification rings Panes get a blue ring and tabs light up when coding agents need your attention Notification panel See all pending notifications in one place, jump to the most recent unread In-app browser Split a browser alongside your terminal with a scriptable API ported from agent-browser Vertical + horizontal tabs Sidebar shows git branch, linked PR status/number, working directory, listening ports, and latest notification text. Split horizontally and vertically. SSH cmux ssh user@remote creates a workspace for a remote machine. Pass --command 'omp "investigate auth"' to run an initial command once in its first remote terminal. Browser panes route through the remote network so localhost just works. Drag an image into a remote session to upload via scp. Claude Code Teams cmux claude-teams runs Claude Code's teammate mode with one command. Teammates spawn as native splits with sidebar metadata and notifications. No tmux required. Browser import — Import cookies, history, and sessions from Chrome, Firefox, Arc, and 20+ browsers so browser panes start authenticated Custom commands — Define project-specific actions in cmux.json that launch from the command palette Programmable — CLI and socket API to create workspaces, split panes, send keystrokes, and automate the browser Native macOS app — Built with Swift and AppKit, not Electron. Fast startup, low memory. Ghostty compatible — Reads your existing ~/.config/ghostty/config for themes, fonts, and colors GPU-accelerated — Powered by libghostty for smooth rendering Keyboard shortcuts — Extensive shortcuts for workspaces, splits, browser, and more Open source — Free and GPL-licensed Install DMG (recommended) Open the .dmg and drag cmux to your Applications folder. cmux auto-updates via Sparkle, so you only need to download once. Homebrew brew tap manaflow-ai/cmux brew install --cask cmux To update later: brew upgrade --cask cmux On first launch, macOS may ask you to confirm opening an app from an identified developer. Click Open to proceed. Why cmux? I run a lot of Claude Code and Codex sessions in parallel. I was using Ghostty with a bunch of split panes, and relying on native macOS notifications to know when an agent needed me. But Claude Code's notification body is always just "Claude is waiting for your input" with no context, and with enough tabs open I couldn't even read the titles anymore. I tried a few coding orchestrators but most of them were Electron/Tauri apps and the performance bugged me. I also just prefer the terminal since GUI orchestrators lock you into their workflow. So I built cmux as a native macOS app in Swift/AppKit. It uses libghostty for terminal rendering and reads your existing Ghostty config for themes, fonts, and colors. The main additions are the sidebar and notification system. The sidebar has vertical tabs that show git branch, linked PR status/number, working directory, listening ports, and the latest notification text for each workspace. The notification system picks up terminal sequences (OSC 9/99/777) and has a CLI (cmux notify) you can wire into agent hooks for Claude Code, OpenCode, etc. When an agent is waiting, its pane gets a blue ring and the tab lights up in the sidebar, so I can tell which one needs me across splits and tabs. Cmd+Shift+U jumps to the most recent unread. The in-app browser has a scriptable API ported from agent-browser. Agents can snapshot the accessibility tree, get element refs, click, fill forms, and evaluate JS. You can split a browser pane next to your terminal and have Claude Code interact with your dev server directly. Everything is scriptable through the CLI and socket API — create workspaces/tabs, split panes, send keystrokes, open URLs in the browser. The Zen of cmux cmux is not prescriptive about how developers hold their tools. It's a terminal and browser with a CLI, and the rest is up to you. cmux is a primitive, not a solution. It gives you a terminal, a browser, notifications, workspaces, splits, tabs, and a CLI to control all of it. cmux doesn't force you into an opinionated way to use coding agents. What you build with the primitives is yours. The best developers have always built their own tools. Nobody has figured out the best way to work with agents yet, and the teams building closed products definitely haven't either. The developers closest to their own codebases will figure it out first. Give a million developers composable primitives and they'll collectively find the most efficient workflows faster than any product team could design top-down. Documentation For more info on how to configure cmux, head over to our docs. To theme cmux (colors, fonts, transparency, sidebar, and more), see Customizing cmux's look. For shell watcher churn and managed-Mac process audit volume, see the supported CMUX_NO_GIT_WATCH=1 mitigation and its Git/PR update trade-offs. Keyboard Shortcuts Workspaces Shortcut Action ⌘ N New workspace ⌘ 1–8 Jump to workspace 1–8 ⌘ 9 Jump to last workspace ⌃ ⌘ ] Next workspace ⌃ ⌘ [ Previous workspace ⌘ ⇧ W Close workspace ⌘ ⇧ R Rename workspace ⌥ ⌘ E Edit workspace description ⌘ B Toggle sidebar ⌥ ⌘ B Toggle right sidebar ⌘ ⇧ E Toggle right sidebar focus Surfaces Shortcut Action ⌘ T New surface ⌘ ⇧ ] Next surface ⌘ ⇧ [ Previous surface ⌃ Tab Next surface ⌃ ⇧ Tab Previous surface ⌃ 1–8 Jump to surface 1–8 ⌃ 9 Jump to last surface ⌘ W Close surface Split Panes Shortcut Action ⌘ D Split right ⌘ ⇧ D Split down ⌥ ⌘ ← → ↑ ↓ Focus pane directionally ⌃ ⇧ H J K L Resize pane left/down/up/right ⌘ ⇧ H Flash focused panel Browser Browser developer-tool shortcuts follow Safari defaults and are customizable in Settings → Keyboard Shortcuts. Command palette navigation shortcuts, including ⌃ P, are also customizable and can be cleared so the keypress reaches the active terminal. Shortcut Action ⌘ ⇧ L Open browser in split ⌘ L Focus address bar ⌘ [ Back ⌘ ] Forward ⌘ R Reload page ⌥ ⌘ I Toggle Developer Tools (Safari default) ⌥ ⌘ C Show JavaScript Console (Safari default) Notifications Shortcut Action ⌘ I Show notifications panel ⌘ ⇧ U Jump to latest unread ⌥ ⌘ U Toggle current item unread state ⌃ ⌘ U Mark current item as oldest unread and jump to next latest unread — Mark all notifications read (unbound by default; configure in Settings or cmux.json) — Clear all notifications (unbound by default; configure in Settings or cmux.json) Find Shortcut Action ⌘ F Find ⌘ ⇧ F Find in directory ⌘ G / ⌥ ⌘ G Find next / previous ⌥ ⌘ ⇧ F Hide find bar ⌘ E Use selection for find Terminal Shortcut Action ⌘ K Clear scrollback ⌘ C Copy (with selection) ⌘ V Paste ⌘ + / ⌘ - Increase / decrease font size ⌘ 0 Reset font size Window Shortcut Action ⌘ ⇧ N New window ⌘ ⇧ O Reopen previous session ⌘ , Settings ⌘ ⇧ , Reload configuration ⌘ Q Quit Nightly Builds Download cmux NIGHTLY (universal; updates then switch to your Mac's architecture automatically) cmux NIGHTLY is a separate app with its own bundle ID, so it runs alongside the stable version. Built automatically from the latest main commit and auto-updates via its own Sparkle feed. Report nightly bugs on GitHub Issues or in #nightly-bugs on Discord. Session restore Quitting cmux saves the current session. On relaunch, cmux restores app-owned state: Window/workspace/pane layout Working directories Terminal scrollback (best effort) Browser URL and navigation history cmux does not checkpoint arbitrary live process state. Ordinary terminals, tmux, vim, shells, and unsupported terminal apps reopen as normal terminals. For live detach/reattach across cmux quit, crashes, and updates, opt in to the local tmux owner with cmux local-tmux; see docs/local-tmux.md for its lifecycle and machine-sleep limits. zellij users can use cmux local-zellij instead; see docs/local-zellij.md. Supported agent sessions can resume when hooks have saved a native session ID. Install hooks after installing the agent CLI so its binary is on PATH: cmux hooks setup cmux hooks setup codex cmux hooks setup --agent opencode cmux hooks setup installs supported agents it can find and prints a summary for skipped agents. Supported resume integrations include Claude Code, Codex, Grok, OpenCode, Pi, Amp, Cursor CLI, Gemini, Rovo Dev, Copilot, CodeBuddy, Factory, and Qoder. Claude Code is handled by the cmux Claude wrapper when Claude integration is enabled in Settings. Advanced users and integrations can attach a custom resume command to the current terminal surface. This is useful for tools with their own durable state, such as tmux sessions or custom agent CLIs: cmux surface resume set --kind tmux --checkpoint work --shell "tmux attach -t work" cmux surface resume show --json cmux surface resume clear --checkpoint work The binding stays attached to the cmux surface. Public CLI or socket-created bindings are stored for inspection and manual restore unless you approve a signed command prefix for automatic restore. Approved prefixes are also bound to the working directory and exact environment values, when present. Review or edit approvals in Settings > Terminal > Resume Commands. cmux only auto-runs resume bindings it marks trusted, such as live process-detected tmux bindings or user-approved prefixes. Sensitive environment keys such as tokens, passwords, secrets, and API keys are dropped before a resume binding is stored. To keep restored agent terminals idle instead of automatically running their resume commands, turn off Settings > Terminal > Resume Agent Sessions on Reopen or set this in ~/.config/cmux/cmux.json: { "terminal": { "autoResumeAgentSessions": false } } This only disables automatic agent resume commands. cmux still restores the saved layout, working directories, scrollback, and browser history. If you need to reapply the last saved snapshot manually, use: File > Reopen Previous Session ⌘ ⇧ O cmux restore-session Each cmux install (stable, nightly, rc, staging, and tagged debug builds) keeps its own saved session. To bring a session from one install into another, for example after trying nightly and switching back to stable, run this from the install you want to open it in: cmux restore-session --from nightly # or stable, rc, staging, debug:<tag> cmux restore-session --export ~/session.json # write this install's saved session to a file cmux restore-session --export ~/session.json --force # replace an existing export file cmux restore-session --from ~/session.json # reopen an exported file The imported session opens as additional windows next to the ones you have, like cmux restore-session; the other install's saved file is only read. Agent resume carries over because hook session mappings in ~/.cmuxterm/ are shared by every install. Browser cookies and logins are per install and do not move. --from <channel> restores another install's own session file with the same trust as your own session, including automatic agent resume. --from <path> treats the file as untrusted: layout, working directories, text scrollback, and http(s) browser tabs restore, but nothing in the file runs automatically. Built-in agents (Claude Code, Codex, Amp, and the rest) resume with the command cmux builds from the agent kind and session id, ignoring launch arguments stored in the file, and only when the working directory already exists on this Mac. Custom agent resume commands, resume bindings, and tmux start commands are kept for manual restore only (approved resume prefixes never apply to them): the CLI reports how many were held back, and in each terminal cmux surface resume show shows the command and cmux restore --surface runs it. Terminal control sequences in the scrollback (clipboard, notifications, links, titles), draft attachments, non-http(s) browser pages and profiles, SSH/cloud connections, and workspace environment variables from the file are dropped. A snapshot saved by a newer cmux (newer session format) is refused with an error; if a downgraded cmux finds one in its own session file, it keeps a copy next to it as session-<bundle id>.schema-v<N>.json. Under the hood, cmux writes a versioned snapshot under ~/Library/Application Support/cmux/ and agent hooks write session mappings under ~/.cmuxterm/. On restore, cmux rebuilds the layout first, then runs the supported agent's native resume command when automatic agent resume is enabled. Read the full guide at https://cmux.com/docs/session-restore. FAQ How does cmux relate to Ghostty? cmux is not a fork of Ghostty. It uses libghostty as a library for terminal rendering, the same way apps use WebKit for web views. Ghostty is a standalone terminal; cmux is a different app built on top of its rendering engine. What platforms does it support? macOS only, for now. cmux is a native Swift + AppKit app. Is there an iOS app? Yes, in beta. Pair your iPhone with your Mac from the Mobile Connect window and attach to your terminals from your phone, with optional forwarding of terminal notifications. It ships on TestFlight as cmux BETA. Early access is included with cmux Founders Edition. See the iOS docs. What coding agents does cmux work with? All of them. cmux is a terminal, so any agent that runs in a terminal works out of the box: Claude Code, Codex, OpenCode, Gemini CLI, Kiro, Aider, Goose, Amp, Cline, Cursor Agent, and anything else you can launch from the command line. Can cmux orchestrate multiple agents and subagents? Yes. When an agent spawns subagents or teammates, cmux turns them into native panes and splits instead of hidden background processes. It supports Claude Code teams and oh-my-opencode multi-model orchestration, so every agent in a run is visible and controllable. Can I use cmux with remote machines? Yes. Open workspaces over SSH and attach to remote tmux sessions, so agents can run on a remote host while you drive them from cmux. See SSH and remote. How do notifications work? When a process needs attention, cmux shows notification rings around panes, unread badges in the sidebar, a notification popover, and a macOS desktop notification. These fire automatically via standard terminal escape sequences (OSC 9/99/777), or you can trigger them with the cmux CLI and agent hooks. Any agent that supports hooks or OSC works, including Claude Code, Codex, OpenCode, and pi. Is cmux programmable? Yes. Every action is available through the cmux CLI and a Unix socket: create workspaces, open split panes, send input, read screen contents, take screenshots, and drive the in-app browser. See the CLI reference and browser automation docs. What can the built-in browser do? cmux can split a real browser pane next to your terminal, and it is fully programmable: navigate, snapshot the DOM, click, type, evaluate JavaScript, and read console and network activity over the same socket API. Agents use it to verify their own web changes without leaving cmux. See browser automation. Does cmux have skills? Yes. Skills are reusable workflows you can give any agent running in cmux, for things like CLI control, workspace automation, settings, and browser surfaces. Browse the open collection at cmux-skills, or read the skills docs. Can I customize keyboard shortcuts? Terminal keybindings are read from your Ghostty config file (~/.config/ghostty/config), including leader sequences and key tables. Ghostty tab actions target cmux workspaces; see the action mapping, precedence, and limitations. cmux-specific shortcuts (workspaces, splits, browser, notifications) can be customized in Settings. See the default shortcuts for a full list. Can I customize cmux? Yes. Terminal rendering uses your Ghostty config, so themes, fonts, colors, and cursor carry over directly. cmux's own settings in ~/.config/cmux/cmux.json control the sidebar, tab bar, split panes, and behavior, and every keyboard shortcut is editable. See configuration. Are my sessions saved? cmux restores windows, workspaces, panes, working directories, and best-effort scrollback when you relaunch. Supported agent integrations can resume from their saved session IDs. Those are reconstructed app state and resume commands; they do not keep arbitrary live processes running. Use cmux local-tmux for live local detach/reattach across cmux quit, crashes, and updates. A local tmux server cannot survive logout, restart, shutdown, or power loss; use cmux ssh-tmux, cmux mosh-tmux, or a persistent cloud VM when the owner must remain online while this Mac is offline. See session restore and docs/local-tmux.md. How does it compare to tmux? tmux is a terminal multiplexer that runs inside any terminal. cmux is a native macOS app with a GUI: vertical tabs, split panes, an embedded browser, and a socket API, all built in, no config files or prefix keys needed. That said, lots of people happily run cmux with SSH and tmux together, and cmux can attach to your remote tmux sessions natively (beta). Is cmux free? Yes, cmux is free to use. The source code is available on GitHub. How can I support cmux? cmux is free and open source, and always will be. If you want to back development and get early access to what's next, including cmux AI, the iOS app, and Cloud VMs, check out cmux Founders Edition. I have a feature request or found a bug? We want to hear it. Open an issue or pull request on GitHub, or email us. Star History Contributing New here? Start here is the short path from "I want to change something" to a merged pull request, including what you can fix without a Mac. Then the contributor guide and fast local checks. Ways to get involved: Follow us on X for updates @manaflowai, @lawrencecchen, and @austinywang Join the conversation on Discord Create and participate in GitHub issues and discussions Let us know what you're building with cmux Community Discord WhatsApp GitHub X / Twitter YouTube LinkedIn Reddit WeChat: Scan the QR code to join the community. Founder's Edition cmux is free, open source, and always will be. If you'd like to support development and get early access to what's coming next: Get Founder's Edition Prioritized feature requests/bug fixes Early access: cmux AI that gives you context on every workspace, tab and panel Early access: iOS app with terminals synced between desktop and phone Early access: Cloud VMs Early access: Voice mode My personal iMessage/WhatsApp Install DMG (recommended) Open the .dmg and drag cmux to your Applications folder. cmux auto-updates via Sparkle, so you only need to download once. Homebrew brew tap manaflow-ai/cmux brew install --cask cmux To update later: brew upgrade --cask cmux On first launch, macOS may ask you to confirm opening an app from an identified developer. Click Open to proceed. License cmux is open source under GPL-3.0-or-later. The cmux server software (web/, the Cloudflare workers, and the relay services listed in LICENSE) uses the Business Source License 1.1 instead: you can read, modify, and run it for non-production use, and production use or self-hosting requires a commercial license. If your organization cannot comply with GPL, commercial terms may be available for portions for which Manaflow controls the necessary rights. They do not relicense third-party material or outside contributions for which Manaflow lacks a separate grant. See LICENSE for the exact scope and contact founders@cmux.com for details.

no score查看详情
Scout·清单github.com

cloudflare/security-audit-skill

A coding-agent skill for multi-phase security audits with independently verified, machine-readable findingssecurity-audit A coding-agent skill that turns your agent into a security auditor. It orchestrates isolated agents through reconnaissance, coverage-led hunting, candidate validation, structured output, independent record verification, and target-neutral reporting. This is the skill that seeded Cloudflare's vulnerability discovery harness, described in Build your own vulnerability harness. The harness grew into a multi-stage, fleet-wide system; this skill is the single-repo starting point it evolved from. What it does The skill runs a structured audit in six phases: Reconnaissance -- map architecture, trust boundaries, input surfaces, prior evidence, and deterministic coverage in architecture.md and coverage-ledger.json. Coverage-led hunting -- assign isolated hunters from ledger units, record their checks, and use coverage critics to find gaps. Candidate validation -- give every unique candidate to a fresh verifier that tries to disprove it. Structured output -- write confirmed, needs_validation, and rejected records to findings.json and validate them against report-schema.json. Independent record verification -- fresh agents verify final source claims. Material replacements receive another independent verifier. Target-neutral reporting -- derive REPORT.md, FINDINGS-DETAIL.md, and NEEDS-VALIDATION.md from the verified records and coverage ledger. The parent runs validate-coverage-ledger.cjs after creating the ledger and after each later ledger update. It runs validate-findings.cjs in Phase 4 and again after every Phase 5 replacement. The verdicts are distinct: confirmed has a complete source trace and bounded observed result, needs_validation has an exact unresolved fact and no severity, and rejected records a disproved candidate. Multiple runs against the same repo are additive. The skill uses prior ledgers and findings to target gaps, revalidate changed source, and carry forward current-source evidence without treating stale or unresolved work as covered. Files File Purpose SKILL.md Setup, core principles, platform terminology, workflow overview, and audit anti-patterns RECONNAISSANCE.md Phase 1 reconnaissance prompts and synthesis instructions HUNTING.md Phase 2 orchestration, hunting methodology, and validation rules ATTACK-CLASSES.md Core, wildcard, and obvious-things attack prompts MEMORY-SAFETY-AND-BINARY.md Memory-safety, binary, and kernel hunting classes for native targets AI-AND-LLM.md Prompt-injection, agent/tool, and output-handling hunting classes for LLM-backed targets WEB-PROTOCOL-AND-AUTH.md HTTP request-framing, cache, and authentication-protocol hunting classes for HTTP-protocol and auth targets CLIENT-SIDE.md DOM-injection, messaging-trust, UI-redress, and prototype-pollution hunting classes for client-side/browser targets SUPPLY-CHAIN-AND-RELEASE.md Dependency, CI, release, signing, update, plugin, and extension hunting classes CLOUD-AND-DEPLOYMENT.md IAM, infrastructure-as-code, container, serverless, ingress, and runtime-configuration hunting classes PROTOCOLS-RPC-AND-MESSAGING.md RPC, serialization, queue, broker, webhook, and streaming-protocol hunting classes RESOURCE-EXHAUSTION-AND-AVAILABILITY.md Shared resource, quota, queue, worker, and operator-spend hunting classes DATA-ISOLATION-AND-LIFECYCLE.md Tenant isolation, cache, search, export, backup, migration, deletion, and restore hunting classes DESKTOP-MOBILE-AND-LOCAL-IPC.md Native app, deep-link, webview, exported-component, helper, daemon, and local-IPC hunting classes VALIDATION-AND-REPORTING.md Phases 3–6 candidate validation, structured output, record verification, and reporting report-schema.json JSON schema for all three findings.json verdicts validate-findings.cjs Zero-dependency validator for findings.json in Phases 4 and 5 validate-findings.test.cjs Findings-validator tests and producer-compatible fixture checks validate-coverage-ledger.cjs Zero-dependency validator for coverage-ledger.json in Phases 1–5 validate-coverage-ledger.test.cjs Coverage-ledger validator tests Installation Install the skill with the Skills CLI: npx skills add https://github.com/cloudflare/security-audit-skill \ --skill security-audit Use --global for a user-level installation: npx skills add https://github.com/cloudflare/security-audit-skill \ --skill security-audit \ --global Run npx skills --help for agent-selection and non-interactive options. Usage Start your coding agent in (or pointed at) the codebase you want to audit, then ask it to do a security audit: security audit this codebase find security vulnerabilities in ./src do a security review, output to ~/audits/my-project The skill activates automatically when the request matches its trigger (security audit, find vulnerabilities, pen-test the code, etc.). A direct codebase audit or pen-test request uses full audit mode. Security questions and focused vulnerability work use guidance mode unless you request report artifacts. In full audit mode, an unspecified output directory defaults to ~/security-audit-skill/<repo-name>/run-<N>. The workflow writes inside the target repository only when you explicitly select a directory that version control ignores. Requirements A coding agent with a model that supports tool use and parallel sub-agents Node.js for the zero-dependency findings and coverage-ledger validators An OS-enforced sandbox for target-controlled builds, tests, processes, browsers, emulators, fuzzers, and fixtures. It must disable external networking, use a sanitized allowlisted environment, enforce resource limits, and allow writes only to assigned scratch paths. Without these controls, the workflow keeps the lead as needs_validation instead of executing target code. Design principles Only confirm established boundary failures. Keep a source-grounded blocked lead as needs_validation with its exact unresolved fact. Adversarial validation. The agent that checks a finding is never the agent that found it. Severity requires impact. Likelihood x impact, not deviation from a checklist. Defense-in-depth gaps are not vulnerabilities. If Layer A prevents the attack, the absence of Layer B is a hardening note. Multiple runs improve coverage. In our test runs, a single run found roughly half of the vulnerabilities that repeated runs found in total. Contact Questions, feedback, or comparing notes on AI-driven security tooling: security-ai-research@cloudflare.com License MIT -- see LICENSE.

no score查看详情
Scout·清单github.com

tester-army/e2e

Next generation e2e testing framework for web and mobile apps.https://tester.army/e2e e2e e2e is an end-to-end testing framework for web and mobile apps. Describe a goal in natural language and an agent drives the app to reach it. Check the result with locators and assertions in the same test. // tests/checkout.e2e.ts import { test, expect } from 'e2e'; test('a member upgrades to Pro', async ({ app, agent, screen }) => { await app.open('/settings/billing'); await agent.act('upgrade the workspace to the Pro plan'); await agent.assert('the invoice preview shows a prorated amount'); await expect(screen.getByRole('status')).toContainText('Pro'); }); An agent step that a later assertion verifies records its actions, and the next run replays them with no model calls until the app changes. Tests without agent steps need no model. Bring your own subscription, API key, or local model. Quick start npx e2e init init asks for an engine, web or mobile, and a model provider, then writes a config and an example test. The quickstart covers the rest. To see a finished setup in your stack, open examples/: Vite, Next.js, Expo, SwiftUI, Jetpack Compose, Kotlin Multiplatform, and Flutter, each a standalone project with a passing suite. Packages Package What it does e2e The SDK, runner, and CLI. @e2e-dev/web Browser engine: Chromium, Firefox, and WebKit through Playwright. @e2e-dev/mobile iOS and Android engine: simulators and emulators through agent-device. @e2e-dev/github Reporter that posts results as a pull request comment. @e2e-dev/kernel Kernel hosted browsers for the web engine. @e2e-dev/eas EAS Simulators hosted iOS simulators and Android emulators for the mobile engine. @e2e-dev/decision Decision-model executors for bounded semantic actions and assertions. Documentation e2e.tester.army/docs. The e2e package ships every page, so coding agents can read them offline in node_modules/e2e/docs. Contributing See CONTRIBUTING.md. Questions go to Discord. Security Please don't open public issues for security vulnerabilities. Follow SECURITY.md and report them to security@tester.army. Telemetry The CLI sends anonymous usage data, such as which commands and engines run and where runs fail, but no test content, app content, or credentials. Opt out with npx e2e telemetry disable or E2E_TELEMETRY_DISABLED=1. Telemetry lists every field. Status Note e2e is in active development on the way to 1.0. APIs and config can still change between minor releases. Made by TesterArmy e2e is built by TesterArmy, the agentic testing platform that runs natural language tests on web and mobile apps, on every pull request or on a schedule. Apache-2.0.

no score查看详情
Analyzed·分析github.com

earthtojake/text-to-cad

earthtojake/text-to-cad 在 GitHub 上发布了名为 CAD Skills 的代理技能库,面向 CAD、机器人和硬件设计场景,包含 11 项从自然语言建模到 3D 打印管理的子技能,可通过 npx 或 Codex/Claude Code 插件安装。

earthtojake/text-to-cad 发布了一个开源代理技能库 CAD Skills,专为 CAD、机器人及硬件设计场景构建。该库包含 CAD 建模(输出 STEP/STL/3MF/GLB 格式)、CAD 本地预览、标准件 STEP 零件查找、DXF 二维绘图、URDF/SRDF/SDF 机器人描述文件生成、SendCutSend 文件校验、G-code 切片、Bambu Lab 打印管理以及隐式 CAD(GLSL 符号距离场)等 11 项子技能。用户可通过 npx skills CLI、Codex 插件市场或 Claude Code 插件市场安装。仓库还提供了 10 个从基础校准块到行星齿轮组的基准测试用例。

框架工具◆ 深度研判▲积极
5.5查看详情
Analyzed·分析github.com

pbakaus/impeccable

pbakaus 发布 Impeccable,一个为 AI 编程智能体提供前端设计指导的技能框架,包含 23 条设计命令、60 条确定性检测规则和实时浏览器迭代能力,支持 Claude Code、Cursor、Codex 等多种 AI 编码工具。

pbakaus 在 GitHub 上开源了 Impeccable 项目,该项目源于 Anthropic 的 frontend-design 技能,旨在解决 AI 生成前端设计的模板化问题。Impeccable 提供了 23 条设计命令(如 init、audit、critique、polish 等)、60 条无需 LLM 即可运行的确定性检测规则以及实时浏览器迭代模式。用户通过 npx impeccable install 安装后,可在多个主流 AI 编码工具中使用 /impeccable 命令进行前端设计的审计、优化和迭代。

框架工具◆ 持续监测▲积极
5.0查看详情
Scout·清单github.com

deepseek-ai/DeepGEMM

DeepGEMM: clean and efficient BLAS kernel library on GPUDeepGEMM DeepGEMM is a unified, high-performance tensor core kernel library that brings together the key computation primitives of modern large language models — GEMMs (FP8, FP4, BF16), fused MoE with overlapped communication (Mega MoE), MQA scoring for the lightning indexer, HyperConnection (HC), and more — into a single, cohesive CUDA codebase. All kernels are compiled at runtime through DeepJIT, requiring no CUDA compilation during installation. DeepGEMM leverages some concepts from CUTLASS and CuTe, but avoids heavy reliance on their templates or algebras. The library is designed for simplicity, with only a limited number of core kernel functions, making it a clean and accessible resource for learning NVIDIA GPU kernel optimization techniques. Despite its lightweight design, DeepGEMM's performance matches or exceeds expert-tuned libraries across various matrix shapes. News 2026.09.30 DeepGEMM Ascend is available! Check DeepGEMM-Ascend for more details Add more optimizations, including locality domain features, check #462 for more details 2026.09.10: Sparse Indexer, Mega Gate, Mega mHC, DeepJIT, MoE and Indexer optimizations and more. Please see #432 for more details. 2026.04.16: Mega MoE, FP8xFP4 GEMM, FP4 Indexer, PDL, faster JIT compilation and more. Please see #304 for more details. For Mega MoE benchmarks, refer to #316. 2025.09.28: DeepGEMM now supports scoring kernels (weighted ReLU MQA logits) for the lightning indexer for DeepSeek v3.2. Please see #200 for more details. 2025.07.20: DeepGEMM now supports both SM90/SM100, and has a full refactor with a low-CPU-overhead JIT CPP module. As NVCC 12.9 will automatically do the FFMA interleaving, all post optimizations will be no longer supported. Please see #112 for more details. 2025.05.14: DeepGEMM now offers weight gradient kernels for dense and MoE backward! See #95 for details. 2025.04.18: DeepGEMM now achieves up to 1550 TFLOPS on H800! See #74, #78, #81, #86 and 340d988 for details. Quick start Requirements NVIDIA SM90 or SM100 architecture GPU Python 3.8 or higher Compilers and standard libraries with C++20 <format> support CUDA Toolkit 12.9 or higher PyTorch 2.3 or higher CUTLASS 4.0 or higher (could be cloned by Git submodule) Development # Submodule must be cloned git clone --recursive git@github.com:deepseek-ai/DeepGEMM.git cd DeepGEMM # Link some essential includes and build the C++ extension cat develop.sh ./develop.sh Installation cat install.sh ./install.sh Then, import deep_gemm in your Python project, and enjoy! Interfaces Notices This library provides optimized GEMM kernels for NVIDIA GPUs with a naming convention: D = C + A @ B. The input shape layout is NT (non-transposed A, transposed B). While the SM90 implementation supports only the NT memory layout (row-major, col-major), the SM100 implementation supports all memory layouts (NT, TN, NN, TT). For example, fp8_gemm_nt will do a D = C + A @ B.T For both architectures, the LHS scaling factor is required to have a TMA-aligned and transposed layout. And the data format for the scaling factor of SM90 and SM100 is different: SM90 requires scaling factors in FP32 format. SM100 requires scaling factors in packed UE8M0 format, which packs 4 UE8M0 into a single torch.int. Please note that operations like input transposition or FP8 casting must be handled separately by the user, please implement or fuse them into prior kernels independently. While the library provides some simple PyTorch utility functions, these may result in slower performance, but our primary focus is on optimizing the GEMM kernels themselves. Normal dense GEMMs (non-grouped) To perform a basic non-grouped FP8 GEMM, call the fp8_gemm_{nt, nn, tn, tt} function. For more details, please refer to the function documentation. Grouped GEMMs (contiguous layout) Unlike traditional grouped GEMMs in CUTLASS, DeepGEMM groups only the M-axis, while N and K must remain fixed. This design is tailored for scenarios where experts in an MoE model share the same shape. For training forward passes or inference prefilling, where each expert may process a varying number of tokens, we concatenate these tokens into a single tensor, referred to as the "contiguous" layout. Note that each expert segment must be aligned to the GEMM M block size (get_mk_alignment_for_contiguous_layout()). For more information, please refer to the m_grouped_fp8_gemm_{nt, nn}_contiguous function documentation. We also provide a K-axis-grouped API for MoE weight backward (with M and N must remain fixed), please refer to k_grouped_fp8_gemm_tn_contiguous for more information. Grouped GEMMs (masked layout) During the inference decoding phase, when CUDA graph is enabled and the CPU is unaware of the number of tokens each expert receives, we support masked grouped GEMMs. By providing a mask tensor, the kernel computes only the valid portions. Use m_grouped_fp8_gemm_nt_masked for this purpose and consult the relevant documentation. An example usage is to use the output of low-latency kernels from DeepEP as input. V3.2 MQA kernels for the indexer The kernel family has two versions, non-paged (for prefilling) and paged (for decoding). Take the non-paged version fp8_fp4_mqa_logits as an example. Its main inputs are: q, a (q_data, q_sf) tuple; SM100 accepts MXFP4/MXFP8 data with packed UE8M0 scales kv, a (kv_data, kv_sf) tuple with shape [seq_len_kv, head_dim] logically weights, tensor with shape [seq_len, num_heads] (BF16 on SM100) cu_seq_len_k_start and cu_seq_len_k_end, int tensor with shape [seq_len] max_seqlen_k, the maximum valid KV span of any query row The output is compressed to [seq_len, max_seqlen_k]; row i stores its valid KV span starting at column zero. For each token i in q, it will iterate all tokens j from [cu_seq_len_k_start[i], cu_seq_len_k_end[i]), and calculate the corresponding compressed logit as: kv_j = kv[0][j, :] * kv[1][j].unsqueeze(1) # [head_dim] out_ij = q[i, :, :] @ kv_j # [num_heads] out_ij = out_ij.relu() * weights[i, :] # [num_heads] out_ij = out_ij.sum() # Scalar For more details and the paged version fp8_fp4_paged_mqa_logits, please refer to tests/test_attention.py. Mega MoE Mega MoE fuses and overlaps EP dispatch, linear 1 and linear 2 (FP8xFP4 or FP8xFP8), SwiGLU, and EP combine into a single mega-kernel, overlapping NVLink communication and tensor core computation. It requires multi-process launch with symmetric memory. Usage: # Allocate symmetric memory buffer # NOTES: requires PyTorch >= 2.9 buffer = deep_gemm.get_symm_buffer_for_mega_moe( group, num_experts, num_max_tokens_per_rank, num_topk, hidden, intermediate_hidden, mma_type='fp8xfp4', # Use 'fp8xfp8' for FP8 routed-expert weights ) # Transform weights (FP4 or FP8 with UE8M0 SF) into the required layout transformed_l1, transformed_l2 = deep_gemm.transform_weights_for_mega_moe(l1_weights, l2_weights) # (Optional) Localize weights into locality domains transformed_l1 = (deep_gemm.localize(transformed_l1[0]), transformed_l1[1]) transformed_l2 = (deep_gemm.localize(transformed_l2[0]), transformed_l2[1]) deep_gemm.destroy_localizer() # Copy inputs into the buffer before each call # You may fuse these into previous kernels buffer.x[:num_tokens].copy_(x_fp8) buffer.x_sf[:num_tokens].copy_(x_sf) buffer.topk_idx[:num_tokens].copy_(topk_idx) buffer.topk_weights[:num_tokens].copy_(topk_weights) # Run the fused mega MoE kernel y = torch.empty((num_tokens, hidden), dtype=torch.bfloat16, device='cuda') deep_gemm.fp8_fp4_mega_moe(y, transformed_l1, transformed_l2, buffer) For the full example with multi-process setup and benchmarking, please refer to tests/test_mega_moe.py. Utilities The library provides some utility functions besides the above kernels: deep_gemm.set_num_sms / get_num_sms: set/get the maximum SM count to use deep_gemm.set_tc_util / get_tc_util: set/get an approximated tensor core utilization ratio deep_gemm.set_pdl / get_pdl: enable/disable Programmatic Dependent Launch (PDL) deep_gemm.use_deterministic_algorithms: enable/disable deterministic algorithms deep_gemm.set_mk_alignment_for_contiguous_layout / get_mk_alignment_for_contiguous_layout: set/get the group-level M/K alignment for contiguous layout deep_gemm.get_theoretical_mk_alignment_for_contiguous_layout: get the theoretical minimum M/K alignment deep_gemm.set_ignore_compile_dims: configure dimensions to ignore during JIT compilation deep_gemm.set_block_size_multiple_of: constrain block sizes to be multiples of a given value deep_gemm.transform_sf_into_required_layout: transform scaling factors into the required layout deep_gemm.get_tma_aligned_size: get the required TMA alignment size deep_gemm.get_mn_major_tma_aligned_tensor: get a MN-major TMA-aligned tensor deep_gemm.get_mn_major_tma_aligned_packed_ue8m0_tensor: get a MN-major TMA-aligned tensor (with packing FP32 into UE8M0) deep_gemm.get_k_grouped_mn_major_tma_aligned_packed_ue8m0_tensor: K-grouped GEMM packing kernel The library also provides some environment variables, which may be useful: Each DG_JIT_* variable falls back to the corresponding global DJ_JIT_* variable when unset. General DG_JIT_DEBUG: 0 or 1, enable JIT debugging features, including compiler command and PTXAS output, load-time reporting, line info, and PTX/SASS dumps; 0 by default DG_PRINT_CONFIGS: 0 or 1, print selected configs for each shape, 0 by default JIT cache DG_JIT_CACHE_DIR: string, cache directory (or a :-separated list of directories) for compiled kernels; lookup searches all paths front-to-back (first hit wins) and a cache miss compiles into the first path, $HOME/.dj by default Compiler selection DG_JIT_NVCC_COMPILER: string, NVCC compiler path; otherwise CUDA is found through CUDA_HOME, CUDA_PATH, which nvcc, then /usr/local/cuda DG_JIT_CPP_STANDARD: integer, C++ standard version, 20 by default Compiler output DG_JIT_PRINT_COMPILER_COMMAND: 0 or 1, print compilation commands, 0 by default DG_JIT_PTXAS_VERBOSE: 0 or 1, show detailed PTXAS output, 0 by default DG_JIT_CHECK_NO_SPILLS: 0 or 1, assert no register spills in compiled kernels, 0 by default DG_JIT_CHECK_NO_LOCAL_MEMORY: 0 or 1, assert no local memory usage in compiled kernels, 0 by default DG_JIT_PRINT_LOAD_TIME: 0 or 1, print kernel load time, 0 by default Debug and profiling DG_JIT_WITH_LINEINFO: 0 or 1, embed source line info for profiling tools, 0 by default DG_JIT_DUMP_ASM: 0 or 1, dump both PTX and SASS, 0 by default DG_JIT_DUMP_PTX: 0 or 1, dump PTX output, 0 by default DG_JIT_DUMP_SASS: 0 or 1, dump SASS output, 0 by default DG_COMM_KERNEL_DEBUG: 0 or 1, zero symmetric buffer before each Mega MoE call for debugging, 0 by default DG_USE_NVIDIA_TOOLS: 0 or 1, skip internal profiling when running under external NVIDIA tools, 0 by default Build options DG_SKIP_CUDA_BUILD: 0 or 1, skip CUDA extension build during installation, 0 by default DG_FORCE_BUILD: 0 or 1, force local build instead of downloading pre-built wheels, 0 by default For additional examples and details, please refer to the test code or review the corresponding Python documentation. Acknowledgement DeepGEMM is inspired by the CUTLASS project. Thanks and respect to the developers! License This code repository is released under the MIT License. Citation @misc{deepgemm2025, title={DeepGEMM: clean and efficient BLAS kernel library on GPU}, author={Chenggang Zhao and Zhean Xu and Liang Zhao and Jiashi Li and Chenhao Xu and Anyi Xu and Shengyu Liu and Kexing Zhou and Kuai Yu}, year={2025}, publisher = {GitHub}, howpublished = {\url{https://github.com/deepseek-ai/DeepGEMM}}, }

no score查看详情
Analyzed·分析github.com

pingdotgg/t3code

T3 Code 是一个为编码代理(Codex、Claude、Cursor、OpenCode)提供的最小化 Web 图形界面,可通过 npx t3@latest 或桌面应用安装,目前仍处于早期开发阶段。

Theo(pingdotgg)发布了 T3 Code,一个为多种编码代理工具提供统一 Web GUI 的开源项目。当前支持 Codex、Claude、Cursor 和 OpenCode 四种代理,用户需预先安装并认证对应 CLI 工具。安装方式包括 npx 命令和 winget/brew/yay 等包管理器。项目处于早期阶段,尚未开放外部贡献,暂无公开文档站点,依赖 Vite+(vp)全局命令行工具。

框架工具◆ 持续监测─中性
3.5查看详情
Analyzed·分析github.com

Panniantong/Agent-Reach

Agent Reach 是一个开源的 AI Agent 互联网能力脚手架工具,通过一条安装命令即可让 Claude Code、Cursor、OpenClaw 等 Agent 获得访问网页、YouTube、Twitter、Reddit、B站、小红书等十余个平台的能力,所有功能免费开源。

Panniantong 于 2026 年发布了开源项目 Agent Reach,旨在解决 AI Agent 在访问互联网平台时面临的付费 API、IP 封锁、登录认证等门槛问题。该项目通过 pip 安装并聚合 twitter-cli、yt-dlp、Jina Reader、Exa 等多个上游开源工具,以脚手架而非框架的方式为 Agent 提供一键配置能力。安装后 Agent 可直接调用各上游工具实现网页阅读、视频字幕提取、社交平台搜索等功能,无需额外付费,Cookie 等凭据仅存储在用户本地。

框架工具◆ 持续监测▲积极
6.0查看详情
Scout·清单github.com

caddyserver/caddy

Fast and extensible multi-platform HTTP/1-2-3 web server with automatic HTTPShttps://caddyserver.com a project Every site on HTTPS Caddy is an extensible server platform that uses TLS by default. Releases · Documentation · Get Help &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; Powered by Special thanks to: Warp, built for coding with multiple AI agents Available for MacOS, Linux, & Windows Menu Features Install Build from source For development With version information and/or plugins Quick start Overview Full documentation Getting help About Features Easy configuration with the Caddyfile Powerful configuration with its native JSON config Dynamic configuration with the JSON API Config adapters if you don't like JSON Automatic HTTPS by default ZeroSSL and Let's Encrypt for public names Fully-managed local CA for internal names & IPs Can coordinate with other Caddy instances in a cluster Multi-issuer fallback Encrypted ClientHello (ECH) support Stays up when other servers go down due to TLS/OCSP/certificate-related issues Production-ready after serving trillions of requests and managing millions of TLS certificates Scales to hundreds of thousands of sites as proven in production HTTP/1.1, HTTP/2, and HTTP/3 all supported by default Highly extensible modular architecture lets Caddy do anything without bloat Runs anywhere with no external dependencies (not even libc) Written in Go, a language with higher memory safety guarantees than other servers Actually fun to use So much more to discover Install The simplest, cross-platform way to get started is to download Caddy from GitHub Releases and place the executable file in your PATH. See our online documentation for other install instructions. Build from source Requirements: Go 1.26.0 or newer For development Note: These steps will not embed proper version information. For that, please follow the instructions in the next section. $ git clone "https://github.com/caddyserver/caddy.git" $ cd caddy/cmd/caddy/ $ go build When you run Caddy, it may try to bind to low ports unless otherwise specified in your config. If your OS requires elevated privileges for this, you will need to give your new binary permission to do so. On Linux, this can be done easily with: sudo setcap cap_net_bind_service=+ep ./caddy If you prefer to use go run which only creates temporary binaries, you can still do this with the included setcap.sh like so: $ go run -exec ./setcap.sh main.go If you don't want to type your password for setcap, use sudo visudo to edit your sudoers file and allow your user account to run that command without a password, for example: username ALL=(ALL:ALL) NOPASSWD: /usr/sbin/setcap replacing username with your actual username. Please be careful and only do this if you know what you are doing! We are only qualified to document how to use Caddy, not Go tooling or your computer, and we are providing these instructions for convenience only; please learn how to use your own computer at your own risk and make any needful adjustments. Then you can run the tests in all modules or a specific one: $ go test ./... $ go test ./modules/caddyhttp/tracing/ With version information and/or plugins Using our builder tool, xcaddy... $ xcaddy build ...the following steps are automated: Create a new folder: mkdir caddy Change into it: cd caddy Copy Caddy's main.go into the empty folder. Add imports for any custom plugins you want to add. Initialize a Go module: go mod init caddy (Optional) Pin Caddy version: go get github.com/caddyserver/caddy/v2@version replacing version with a git tag, commit, or branch name. (Optional) Add plugins by adding their import: _ "import/path/here" Compile: go build -tags=nobadger,nomysql,nopgx Quick start The Caddy website has documentation that includes tutorials, quick-start guides, reference, and more. We recommend that all users -- regardless of experience level -- do our Getting Started guide to become familiar with using Caddy. If you've only got a minute, the website has several quick-start tutorials to choose from! However, after finishing a quick-start tutorial, please read more documentation to understand how the software works. 🙂 Overview Caddy is most often used as an HTTPS server, but it is suitable for any long-running Go program. First and foremost, it is a platform to run Go applications. Caddy "apps" are just Go programs that are implemented as Caddy modules. Two apps -- tls and http -- ship standard with Caddy. Caddy apps instantly benefit from automated documentation, graceful on-line config changes via API, and unification with other Caddy apps. Although JSON is Caddy's native config language, Caddy can accept input from config adapters which can essentially convert any config format of your choice into JSON: Caddyfile, JSON 5, YAML, TOML, NGINX config, and more. The primary way to configure Caddy is through its API, but if you prefer config files, the command-line interface supports those too. Caddy exposes an unprecedented level of control compared to any web server in existence. In Caddy, you are usually setting the actual values of the initialized types in memory that power everything from your HTTP handlers and TLS handshakes to your storage medium. Caddy is also ridiculously extensible, with a powerful plugin system that makes vast improvements over other web servers. To wield the power of this design, you need to know how the config document is structured. Please see our documentation site for details about Caddy's config structure. Nearly all of Caddy's configuration is contained in a single config document, rather than being scattered across CLI flags and env variables and a configuration file as with other web servers. This makes managing your server config more straightforward and reduces hidden variables/factors. Full documentation Our website has complete documentation: https://caddyserver.com/docs/ The docs are also open source. You can contribute to them here: https://github.com/caddyserver/website Getting help We advise companies using Caddy to secure a support contract through Ardan Labs before help is needed. A sponsorship goes a long way! We can offer private help to sponsors. If Caddy is benefitting your company, please consider a sponsorship. This not only helps fund full-time work to ensure the longevity of the project, it provides your company the resources, support, and discounts you need; along with being a great look for your company to your customers and potential customers! Individuals can exchange help for free on our community forum at https://caddy.community. Remember that people give help out of their spare time and good will. The best way to get help is to give it first! Please use our issue tracker only for bug reports and feature requests, i.e. actionable development items (support questions will usually be referred to the forums). About Matthew Holt began developing Caddy in 2014 while studying computer science at Brigham Young University. (The name "Caddy" was chosen because this software helps with the tedious, mundane tasks of serving the Web, and is also a single place for multiple things to be organized together.) It soon became the first web server to use HTTPS automatically and by default, and now has hundreds of contributors and has served trillions of HTTPS requests. The name "Caddy" is trademarked. The name of the software is "Caddy", not "Caddy Server" or "CaddyServer". Please call it "Caddy" or, if you wish to clarify, "the Caddy web server". Caddy is a registered trademark of Stack Holdings GmbH. Project on X: @caddyserver Author on X: @mholt6 Caddy is a project of ZeroSSL, an HID Global company. Debian package repository hosting is graciously provided by Cloudsmith. Cloudsmith is the only fully hosted, cloud-native, universal package management solution, that enables your organization to create, store and share packages in any format, to any place, with total confidence.

no score查看详情
Scout·清单github.com

cloudflare/cloudflare-os

Agent workspace built on Cloudflare Workers for creating documents, building apps, and running agents with your company’s context and systems.https://os.cloudflare.appCloudflare OS: An AI productivity environment Cloudflare OS is an "operating system" for AI productivity originally developed for use inside Cloudflare. A large portion of Cloudflare's workforce -- from engineering to sales and everything in between -- uses Cloudflare OS every day to help them do their jobs. This is not a traditional computer operating system. We use the term "operating system" in two senses: An operating system for the company to be productive with AI, in a way that is safe, so that the security team can sleep at night. An operating system for AI workloads, analogous to the sense in which a traditional operating system manages compute workloads. Cloudflare OS provides three things in particular: An agent chat UI where you can ask agents to do tasks, preloaded with knowledge about how your company operates. Sandboxed application development, so that you can ask agents to build "gadgets" (small personal apps) and safely share what you've built with others. A security framework, called Gatekeepers, that applies guardrails to both agents and apps such that non-technical users can safely "go nuts" and nothing bad will happen. We are making Cloudflare OS open source so that others can copy it and customize it for their own company. The idea is not that your company uses Cloudflare OS, but rather that you make it "Your Company OS". Quick Start To quickly run Cloudflare OS locally, install pnpm, then do: pnpm run-local Then visit: http://localhost:8787 This runs the whole stack locally on wrangler and workerd. This is not meant for production use, but is a quick way to see what the product does. Alternatively, you can deploy to your Cloudflare account. (More options at the end of this readme.) What to try Try prompts like: "Make slides for my upcoming meeting with a customer." (This will use the built-in slides blueprint.) "Make a collaborative whiteboard app." (This will create a new app from scratch.) "Make a tic tac toe game." followed by "I'll be X and you be O. I've made my first move. Your turn." "Make an issue dashboard for this GitHub repo." (Attach a repo; requires that the GitHub integration is configured.) "Fix the typos in this Google Doc." (Attach a doc; requires that the Google integration is configured.) WARNING: Early access Cloudflare OS is in a state of heavy development. This repository is actually version 2, a complete rewrite taking what we learned from version 1 and putting it on a new foundation. As of the August 2026 release, Cloudflare OS v2 is very capable, but still has many rough edges. We know, and we're working on it. For now, consider this an "early access" release. Overview: What is Cloudflare OS really? Gadgets: A new way of thinking about software Cloudflare OS is more than just another chatbox with connectors. The system revolves around a new approach to software, where every user runs their own copy of the productivity apps they use. When you create a slide deck in Cloudflare OS, you are not calling out to some SaaS software running in the cloud. The system creates a private instance of the slide deck software just for you. We call this a "gadget". This instance runs in a separate sandbox from everyone else's slide decks. This has two profound effects: It's impossible for the slide deck app to have a security bug that leaks your slides to an attacker. The Cloudflare OS sandbox controls all access to your private instance of the app. If you want, you can freely modify the code. If the slide deck app is missing a feature you need, you can just ask your agent to add it. And because of point 1, it's totally safe to do so. This is a big departure from the last 25 years of cloud architecture and "Software as a Service", but we think AI has changed the equation. When any user is capable of prompting an agent to add the features they need, the centralized model of software stops making sense. Gatekeepers: A capability-based security layer Gatekeepers are like supercharged MCP servers. When you introduce an agent or Gadget to an external resource, a Gatekeeper is created to manage that access. The Gatekeeper is a piece of software specific to each external service which moderates a Gadget's connection to that service. It: Provides a clean Cap'n Web API to the service (wrapping whatever API the service provides natively). Handles authorization (e.g. via OAuth). Enforces narrow access to only the specific resource the user intended. Logs every action the Gadget (or agent) performs, for your review. For any action which has side effects, provides the human user an opportunity to approve or deny the action ("human in the loop"). On the last point, Gatekeepers implement a significant advancement in the state of the art. Traditionally, human-in-the-loop setups require the human to approve actions synchronously. When the agent wants to do something, it has to stop and wait for said approval before it can continue. This is annoying: you give your agent a task, then walk away and get a coffee, only to come back and find the agent got stuck on an approval on the first step and has made no progress. As a result, people often give in and set their agents to "auto-approve", or --dangerously-skip-permissions, which is, obviously, unsafe. Gatekeepers provide a better way: When the agent (or Gadget) performs an action that requires approval, the Gatekeeper will simulate the outcome locally, allowing the agent to proceed and queue up more actions. The Gatekeeper tells the agent that the action completed, and if the agent tries to read back the results, the Gatekeeper gives it simulated results. Once the agent is done, the user may approve or reject the actions in bulk, or one-by-one, but either way, they can do it later, when it is convenient. Logistically, each Gatekeeper is implemented as a separate Worker. In the future, we envision Gatekeeper services being deployed and maintained independently from OS instances, but the details have yet to be worked out. For now, we have provided a few interesting Gatekeepers in this repository which you can deploy together with your own OS instance. Think of an office suite The basic user experience of Cloudflare OS is something like an online office suite, like Google Docs or MS Office. But, imagine that instead of a fixed set of file types (document, spreadsheet, slide deck), each file -- or "Gadget" -- is potentially its own custom application, written by AI to serve exactly your needs. Just like office docs, each gadget is private by default, but can be shared -- securely -- in order to collaborate with your team or your friends. Just like office docs, you can have thousands of them. You can create them on a whim. Just like office docs, you can start from "templates" -- called "Blueprints". But where an office template is just some content, a Blueprint specifies a whole application. Like office docs, you can create new templates (blueprints) from your own docs (Gadgets) and share them with others. But when you do so, you are sharing the code for a whole app. It kind of is an Operating System The OS terminology isn't entirely marketing. Cloudflare OS is actually analogous to an operating system on a technical level. Normal OS Cloudflare OS kernel packages/workshop-backend device drivers packages/gatekeeper-* shell packages/workshop-frontend processes gadgets executables blueprints users users ACLs shared permissions ??? agents Our "kernel" is in the workshop-backend package. The backend legitimately does a lot of things similar to real OS kernels: it connects users to programs and devices (Gadgets and Gatekeepers, as we call them) while implementing security by sandboxing applications and enforcing access control. In this analogy, Gatekeepers -- which connect users and agents to external services -- are like drivers -- which connect users and programs to external devices. There is one thing that traditional OSes don't really manage today, but Cloudflare OS does: AI agents. If you think about it, this is really a missing feature in traditional OSes. We believe that AI agents cannot simply be treated as users. They must be accountable to a human user, while at the same time having their own restricted permissions. Agents do work by writing snippets of code and executing them on the fly. The ideal security model for all of this is capability-based security, not access control lists. See what I mean? Perhaps traditional OSes ought to give AI agents special treatment, too. Built on Workers, by the Workers team Cloudflare OS is built on Cloudflare Workers, making heavy use of Durable Objects, Dynamic Workers, and Facets in particular. Every workspace is its own Durable Object, every Gadget runs in a Dynamic Worker Facet, and Gatekeepers also install facets into each workspace to manage access to remote services. Cloudflare OS is, in fact, built by the very people who built Workers itself. It uses cutting-edge features of the Workers Runtime -- in fact, Dynamic Workers, Facets, and several other features were added to the runtime specifically to support Cloudflare OS, with more to come. Studying the Cloudflare OS source code is a great way to understand how the Workers Runtime team thinks Workers should be used. Being built on Workers does not mean that Cloudflare OS can only run on Cloudflare. In fact, workerd, the Cloudflare Workers Runtime, is itself open source, and Cloudflare OS can run entirely on top of it on your own servers. Features General multi-purpose agent The Cloudflare OS coding agent is actually a fully multi-purpose agent that can perform arbitrary tasks; like other popular coding agents, you don't have to code with it. You can use it to build Gadgets, but you can also skip the Gadget and just have the agent perform tasks directly. The Cloudflare OS agent is a Code Mode agent -- it performs tasks by writing and immediately executing snippets of code. It can be connected to external resources using Gatekeepers (like MCP -- see below). Build apps with AI While you can code a Gadget by hand if you want, the expectation is that AI writes the code for you. Cloudflare OS features a built-in coding agent that will build whatever you ask it, test it for you, and debug errors. You can choose your LLM. Cloudflare OS works with many major AI model providers and self-hosted models, with more providers being added all the time. Because of the tightly-integrated and simplified nature of the platform, even when using the same underlying AI models, the Cloudflare OS coding agent often performs better and faster with fewer tokens than a general-purpose coding agent would. Collaborate with AI Every app built with Cloudflare OS automatically has an agent-friendly API. That means, after you've asked AI to build the app, you can also ask AI to collaborate with you inside the app. No need to build an MCP server nor integrate a custom agent loop. It's just there by default. This works because the client and server portions of a Gadget are required to communicate via Cap'n Web RPC. This is a win-win: Cap'n Web is extremely low-boilerplate, which makes it easy for agents to work with. You basically just define a method on your server, then call it from your client, as if it were a local call. Meanwhile, it means that the server necessarily exposes an easy-to-understand API which could be called directly by an agent. The AI Agent harness uses Code Mode for tool calling, making it trivial to expose the Gadget's API directly for the agent to invoke. Real-time Multiplayer You can share your Gadget just like you'd share a document in a typical online office suite. You can give specific users access, or create a share link that provides access to anyone who opens it. And just like those online office suites, you'll be able to see your collaborators' actions in real time. This works because every Gadget is backed by a Durable Object, Cloudflare's stateful serverless primitive which makes real-time multiplayer collaboration easy. It's so easy that the coding agent just implements it by default, without being asked. Blueprints: Share your code If you've created a Gadget that might be useful to others, but you don't want to share the Gadget itself, you can instead share a Blueprint, allowing other people to create their own copy of the Gadget. A Blueprint is essentially a copy of the code. It may sound simple, but Blueprints are a major change from cloud software tradition. Traditionally, if you create a web app that you want to share with other users, you host the app on your server, and the users connect to that. Blueprints are much more like mobile apps and traditional PC apps: every user runs their own copy of the software. In the age of AI, this change is critically important. On one hand, AI empowers an individual developer to build more than ever, but it is still difficult for an individual developer to maintain an online service; this eliminates the need. On the other hand -- and even more importantly -- allowing each user to run their own copy of the software empowers the user to change the software to meet their needs, using AI. No need to file a feature request, no need to beg the developer to prioritize it. The end user can solve their own problems. Sandboxed and secure by default Each Gadget runs in a secure sandbox that prevents it from talking to the internet at all without your explicit consent. In particular: The server runs in a Dynamic Worker which has had its access to the internet disabled. It can only communicate with specific external resources that you have explicitly designated, via Workers Bindings. The client code runs in a sandboxed iframe. This iframe can communicate with its server only via a Cap'n Web RPC session provided over postMessage() to the parent frame. The iframe is otherwise blocked from accessing the internet (to the maximum extent allowed by browsers, via Content-Security-Policy and iframe sandbox settings). Capability-based access control Each agent, and each Gadget, by default has access to nothing. Even if you've configured the Gadget Workshop with access to external accounts, agents and Gadgets do NOT automatically get to use them. Instead, you must introduce each agent (or Gadget) to any particular resources you want it to access. For instance, you may introduce a GitHub repository by pasting a link to it, or clicking "add resource" and selecting it via the UI. An agent can also request an introduction to a resource it thinks it needs, which you can then provide or deny. This differs from most agent harnesses, where MCP servers are configured upfront, making broad access to all your services ambiently available to the agent in every chat. Capability-based introductions keep each agent restricted to only the access it actually needs for the job at hand. Get Started Deploy to your Cloudflare account We've built an online flow that helps you deploy to your own Cloudflare account: https://os.cloudflare.app/deploy Or, for more sophisticated deployment, with your gatekeepers and potentially code changes, check out our deployment starter repo: https://github.com/cloudflare/cloudflare-os-starter Run locally To quickly run Cloudflare OS locally, install pnpm, then do: pnpm run-local Then visit: http://localhost:8787 This runs Cloudflare OS using wrangler, the Workers developer tooling CLI. This is not the right way to run the OS on a production server, but it works fine for trying it out on your local machine. Your data will be stored in a subdirectory named .wrangler. Deploy to your own server using workerd COMING SOON Cloudflare OS can run entirely on workerd, Cloudflare's open source runtime for Workers. In fact, the "run locally" instructions above use workerd under the hood. We are still working on documentation and tooling to help you smoothly deploy the OS on top of workerd on your own servers. If you are feeling adventurous, read the low-level documentation for workerd config (or point your agent at it) and have a go. Configuring external services Many Gatekeepers require configuration in order to be able to connect to third-party services, including obtaining OAuth client credentials for each service. Unfortunately, many service providers intentionally do not make this easy, since the intended audience for OAuth is developers. Each gatekeeper package contains instructions for how to set it up: GitHub API Google API Cloudflare API Supabase API Notion API Confluence API Email Workers Home Assistant Slack API Spotify ZoomInfo API Developing When developing, you'll want to run the front-end and back-end as two separate commands in two terminals: pnpm dev-server pnpm dev-client Then visit: http://localhost:3000 Contributing At this time, we are not seeking outside contribution. AI has made writing code easy. The hard part, today, is not writing the code, but reviewing it, making sure quality stays high, and keeping the product coherent. In that light, unfortunately, external code contributions are "donating" the easy part of the job, while creating more of the hard work. With that said, we are happy to accept small, trivially-verified PRs that fix a problem. However, we ask that you refrain from submitting low-value PRs (e.g. typo fixes) or PRs that are more than a dozen or so lines. Such PRs will be closed with a reference to this guideline. If you have a big idea you'd like us to consider, feel free to open a discussion about it. This policy may change in the future as the project matures. Until then, thank you for your understanding. Credits Cloudflare OS has far too many open source dependencies to list here. But, we'd like to highlight a few that do particularly heavy lifting: Pi (specifically, pi-agent-core), which made it easy to support every LLM provider with one API. CodeMirror provides our code editor UI and operational transform implementation for synchronizing real-time edits. isomorphic-git is used to implement the backing storage for Gadget code and integration with external git servers. Vite, which makes the development loop so pleasant.

no score查看详情

第 1 / 10 页·共 184 条

…