零轮询设计:如何用文件触发实现 AI Agent 双向通信

2 阅读2分钟

背景

在构建 AI Agent 应用时,常常需要实现跨系统的任务调度。传统方案多用轮询机制,定期检查任务队列,但这会带来一个问题:Token 浪费

即使没有新任务,Agent 也要定期"空转"查询,浪费 API 调用额度。

解决思路

我开源了一个小工具 qclaw-workbuddy-bridge,用文件触发机制替代轮询:

任务提交 → 写入 .trigger 文件 → launchd 检测 → 启动处理

只有真正有任务时才启动,零浪费。

技术实现

1. 任务队列结构

{
  "tasks": [
      {
            "id": "task_001",
                  "status": "pending",
                        "command": "分析文档并生成摘要",
                              "created_at": "2026-04-21T10:00:00Z"
                                  }
                                    ]
                                    }
                                    ```
                                    
                                    ### 2. 触发机制
                                    
                                    ```python
                                    # 提交任务时
                                    with open(QUEUE_FILE, 'w') as f:
                                        json.dump(queue, f)
                                            
                                            # 写入触发文件
                                            Path(TRIGGER_FILE).touch()
                                            ```
                                            
                                            ### 3. launchd 配置
                                            
                                            ```xml
                                            <key>WatchPaths</key>
                                            <array>
                                                <string>/Users/xxx/.workbuddy/queue/.trigger</string>
                                                </array>
                                                ```
                                                
                                                当 `.trigger` 文件被修改时,launchd 自动启动处理脚本。
                                                
                                                ### 4. 处理流程
                                                
                                                ```python
                                                def process_tasks():
                                                    tasks = load_queue()
                                                        for task in tasks:
                                                                if task['status'] == 'pending':
                                                                            execute(task)
                                                                                        task['status'] = 'done'
                                                                                            save_queue(tasks)
                                                                                                
                                                                                                    # 处理完成后删除触发文件
                                                                                                        Path(TRIGGER_FILE).unlink()
                                                                                                        ```
                                                                                                        
                                                                                                        ## 效果对比
                                                                                                        
                                                                                                        | 方案 | Token 消耗 | 响应延迟 |
                                                                                                        |------|-----------|----------|
                                                                                                        | 轮询(每分钟) | 1440 次/天 | <60s |
                                                                                                        | 文件触发 | 仅实际任务 | <1s |
                                                                                                        
                                                                                                        按每天 10 个任务计算,轮询方案浪费 **99%** 的 API 调用。
                                                                                                        
                                                                                                        ## 实际应用场景
                                                                                                        
                                                                                                        ### 场景 1: 微信任务自动化
                                                                                                        
                                                                                                        ```
                                                                                                        用户在微信/QClay 提交任务 → WorkBuddy 自动执行 → 结果推送回微信
                                                                                                        ```
                                                                                                        
                                                                                                        无需切换 App,微信就是 AI 指挥中心。
                                                                                                        
                                                                                                        ### 场景 2: 跨 Agent 通信
                                                                                                        
                                                                                                        ```
                                                                                                        Agent A 提交任务 → Agent B 处理 → 结果回传
                                                                                                        ```
                                                                                                        
                                                                                                        不同 AI Agent 之间通过共享队列通信,无需中心化服务。
                                                                                                        
                                                                                                        ## 开源地址
                                                                                                        
                                                                                                        GitHub: https://github.com/liuboacean/qclaw-workbuddy-bridge
                                                                                                        
                                                                                                        **功能特性**:
                                                                                                        - ✅ 零轮询设计 — 不浪费 API 调用
                                                                                                        - ✅ 双向通信 — 任务提交 + 结果查询
                                                                                                        - ✅ macOS 原生 — launchd 支持
                                                                                                        - ✅ 事件驱动 — 文件触发机制
                                                                                                        
                                                                                                        欢迎 Star、Issue 和 PR!
                                                                                                        
                                                                                                        ## 总结
                                                                                                        
                                                                                                        文件触发机制适合:
                                                                                                        - 任务密度不高的场景
                                                                                                        - 需要节省 API 调用
                                                                                                        - macOS 环境
                                                                                                        
                                                                                                        如果你的 AI Agent 也在为轮询烦恼,不妨试试这个思路。
                                                                                                        
                                                                                                        ---
                                                                                                        
                                                                                                        **相关项目**:
                                                                                                        - [ticktick-cli](https://github.com/liuboacean/ticktick-cli) - 滴答清单命令行工具
                                                                                                        - [workbuddy-evolution-stack](https://github.com/liuboacean/workbuddy-evolution-stack) - AI 自学习记忆引擎