不断演变的AI

付我钱让我把这变成一个合适的产品 扔一条线给我 [email protected]

思想的起源于一切

为什么人类大脑在“20”上运行真实的--时间认知, 而我们最好的人工智能模型需要兆瓦来谈论早餐?

现代LLMs的目的是要像一个巨大的皮层 —吨的记忆 ,吨的性能 单@. 执行人类的任务会不遗余力地完成 他们用数十千兆字节的记忆来咀嚼千瓦的力量 . 如果大脑在“20 watts@.”上工作的话,这是正确的

这里的'}他们错过了什么 ': 大脑是' 多个专门次系统 @,Q 动作@,QQ 内存存储 #(QQ#in color_!),}所有由皮层协调的*Llodm do}('*MSKT *他们就像一个巨大的思维引擎,夹在哑基建上 200)}♪.}他们的储存是'QQQT 适应=.}它们不做调整 {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}他们没有完成 {\fnarial black\fs12\shad0\4aH00\fscy11\fscx90\fscy110}

我曾经是一个心理学家 ,,所以我想到这样的事情... ...

*" 夏普认知稳定 复杂认知 ."

您的大脑每一步步步步都计算如何行走 . * 它会卸载到快速的,\ 便宜的MS K4\ 自动子系统@. 稳定可以释放昂贵的前前额皮层来处理新问题 .\ DISE做同样的事情:}它能用廉价的 Python脚本来取代昂贵的LLM电话_,\ 解开边境模型,解决真正棘手的问题.\ 该系统通过简化“,”而不是更复杂的%.来稳定自身

电梯 Pitch

如果你的人工智能工作流程意识到 它需要人工智能 并变成Python脚本 当模式变得清晰时, 它将工作流程作为可测试工具存储在 RAG substrate @.} 它建立作为可以测试的工具的流程。 当你需要更多特性,}它以即时 Python@.}取代LLM电话。 当您需要更多的功能的时候, 它只构建了 '需要什么?

一. 导言导言 导言 导言 导言

今天大多数的人工智能系统都是像我的第一个 PHP 脚本 circa @2003—gfragile@, 无法测试\ ,, 当它们打破了#, 你'得到同样多的机会去调试它们 就像向一个迷惑的美国人解释 Brexit=.】

当他们失败时,你可以告诉为什么 他们漂移的时候 会),你注意到直到生产为止 当您需要改进它们时 ?回到1.数字Sisyphus}.

如果每个AI工具都是像正常软件一样 从第一天开始 —通过测试

这是#'_t蒸汽警告~.}它的工作代码>'}这里是#MS K3} AI工程在成长时应该如何工作?

目录目录

问题在于仍然在西部

让我用图表来给你画一张图片 , 因为I'那么花哨

graph TD
    A[Traditional AI Development] --> B[Write Prompt]
    B --> C[Hope for Best]
    C --> D{Does it work?}
    D -->|Sometimes| E[Ship It™]
    D -->|Usually| F[Tweak Prompt]
    F --> C
    E --> G[Production]
    G --> H[Silent Drift]
    H --> I[Everything's Fine...]
    I --> J[Until It's Not]
    J --> K[Panic]
    K --> L[No Audit Trail]
    L --> M[Start Again]

    style K stroke:#f96
    style L stroke:#f96
    style M stroke:#f96

这听起来很熟悉。 ? M?: 大多数人工智能系统是如何建立起来的?

是什么使得这个不同的?}

这里的' @% action a AI # " chool "} 在我的系统里, 从 CLI, > 没有烟雾和镜像#:}

flag_potential_violations_base/
├─ flag_potential_violations_base_plan.txt   ← generation plan
├─ flag_potential_violations_based_on_predefined_thresholds.feature   ← BDD spec
├─ interface.json                            ← declared IO contract
├─ specification.md                          ← intent & description
├─ main.py                                   ← implementation (generated)
├─ test_main.py                              ← unit + BDD tests
├─ locust_flag_potential_violations_base.py  ← load/performance tests
└─ node_runtime.py                           ← runtime integration (a mock of it's tool call for testing use)

此文件夹结构@ ? @ that'} 我不是用 Figma 做的模型来给你留下深刻印象的吗? 实际产出“. ”每个文件“. ” 来自AI本身的“MS K2 ”

每个节点都是:

“| 属性”“|”意指“MSSK2” | ------------- | ----------------------------------------- | &+BDD测试自出生起就存在 @|可稽核的@|总能证明它为何表现得像做#| @| 挥发性 | 通过健身比较可以改善#| “|”基准测试“| perf/”包括“MS K3” |可重新使用|成为程序内存的一部分{|

这是' 即时工程 . It's MSSK2" AI作为纪律软件@— @ 那种你可以真正信任的制作方式, 而不用每分钟检查一次 SLEK1@ minutes @ . @

在这里,这是非常聪明的 比点 : 他们只是Python脚本. proper}MSKK1 boring , 测试的 Python 脚本@. 但他们生活在一个基于 RAG- 基础进化基质中, 其中每个工具' 的规格都成为其身份的一部分 =. 这个系统可以动态地从工作流程到小实用脚本

**如果你的 AI-}驱动工作流程决定 它真的真的需要 A MESSK2 = *** 这是数据变换 , 为什么我叫LLM ?" 所以它产生纯的 Python 脚本 *.}下次你提出同样的要求时 参考@ . @ 无API calls@ MS K1 @ 没有代号 @ I, @ 没有长期性 @ NSK3 @ 只是无聊 @ MPK4 @ fastQ,} 可预测的 Python@. @

或者你需要更多 . 也许工作流程需要一个额外的验证检查 需要时仅加“.”这个系统仅以这些新部件作为工具来构建这些新的部件, 可能基于现有的工具“,”, 也许完全全新的“MS K3”, 但总是可以预测到‘,’

升级一个工具@( @ @ in a guidened\ ,}严格可测试的方式 @),}和所有使用该工具的工作流程将立即受益\ .}没有重新调配.}无连串更改 #.}只是更好的工具_, 自动提供给所有人=.}

如何实际工作?

这里的'+#这里没有其他人正在做的 Bit nobody no else is doing 工具是 @"_AI"}(一个单一模型='_BARBAR_MSSK6) a 专门项目小组@, 每人有仔细调整的启动提示@, 工作像一个合适的软件工程队}#.

Forge 工作流程@: @%

1. 特殊病例检测 @ –_ {"} 是否这是我们已经处理过的一项共同任务 @ I?"} @ O( 未来CLI会变换以自动添加这些常见模式@ MS K5}
2. 任务分解 @–#A相当不错的LLM@(}当地我用的是 7_B型号的, 200)}没有什么能打破提示性":\Z"#我怎么解开这个?
3. 平行和顺序规划 – 决定什么可以平行运行
4. 生成工具调用 *–产出 call_tool("tool_name", prompt) - 这是可写性的关键
5. RAG 查询 –}“MSKO}”是否"@tool_Name"存在? “?如果有的话,“MS K5使用它” 如果没有‘,’则即成为下一个例子的指令。
6. 循环分解 – 下一個 Forge 做同樣的分解 , 一直到小Q, 單元- 可測步

这是突破 . 任务被细分为原子操作@— @就像我在“30”年中学会的做的那样 建筑软件_.}小本地LMS 足够好 当任务微小且监督员提供详细的执行指令时, 代码生成的代号@. @

这里的'是一个真正的例子, 说明这些指示看起来像@. 监督员说 @'。

• 精密的算法 @ ( @ 地形学排序@ MS K1} 关键路径方法 @ MPK2
• 带有类型定义的数据结构
• 带有输入@ / output speces 的函数签名
• 性能限制 @(O(VMS K2E)时间=,O(V})太空 )
• 安全限值 @( @max@1000}任务_)
• 附有预期投入和产出的完整测试案例
• JSonson 输入@/ @ 输出格式

“7B 型号” 可以写出此图中的固态代码, 因为没有要求它“ ' ” 不设计任何文件“ I— ” 只要执行一个详细的蓝图“. ” 。 那个M' 为什么小型模型在这个系统中为代码生成工作? .

当 Forge 运行工作流程“ ,” 时, 它“ I'” 仍然可以通过 RAG @ MS K2} 动态合成 。 如果一个新的“ O,” 更好的工具显示通过相同的测试“ MSSK4” 将自动使用“ MPK5 ” 并下次记住 “. ”

让我用另一个图表来给你们展示建筑 因为显然我可以帮助自己 :

graph TB
    subgraph "RAG-Based Tool Substrate"
        A[Semantic Intent] --> B[Plan Generation]
        B --> C[Contract Definition]
        C --> D[Code Generation]
        D --> E[Test Generation]
        E --> F[Fitness Evaluation]
        F --> G{Passes?}
        G -->|Yes| H[RAG Storage]
        G -->|No| I[Evolutionary Improvement]
        I --> D
        H --> J[Tool Specification + Code]
    end

    subgraph "Dynamic Composition"
        J --> K[Workflow Assembly]
        K --> L[Tool Discovery via RAG]
        L --> M[Runtime Execution]
        M --> N{Tool Upgrade?}
        N -->|Yes| H
        N -->|No| O[Continue]
    end

    style H stroke:#9f6
    style J stroke:#9f6
    style L stroke:#6cf

RAG基底是秘密的酱汁 . 每一个工具@' @%s profession @—}它的用途是#, 它的健身得分@MS K4}当您需要一个工具,}时,系统会发现最佳匹配=.} 当您升级了一种工具>,}每个使用它的工作流都会自动得到改进_.}

它就像拥有一个自 己的- 的组织工具箱,随着时间推移变得更聪明

内存问题@:停止重新学习如何驱动

正常AIs使用“"quick研究” “"}方法”“MSC2” 每当他们完成一项任务,, 他们"MS K1re cramming for a checklegation — 阅读了所有上下文 ', 找出问题所在',\ 提出一个解决方案 'I." It'}就像每次你坐车都得重修驾驶课一样 测试测试 @( MSKO}虽然这又是一个问题, 经验教训想象一下解释离合器每天早上 在你上下班前做什么

现代代码 CLIs 有部分解答@: @} 查看您的 LAUDE . @ md,} 或者一群散落在 < MS K3 > 上面的奇奇怪怪的标记 docs

DISE其实记得. 当它解决了一个问题时 , 它将解决方案存储为在 RAG substrate @.中测试过的“,记录下来的工具” 下次@? 它只是使用它.No reporting- 学习MS K6 没有reQ-figling. No NSK9让我再次读取您所有的上下文文件@."} 它昨天驱动了这条路线 ,} 它知道转弯的位置是MSC12

这直接与I' 在我的语义学情报系列中,

• 部件“8:” 工具全部向下 优化工具箱的自定义@ - @ 优化工具包
• @ 9:_ self@ MS K1_ 治疗工具 直线进化
• DISE 烹饪器 工作流程构成

每个节点都已经有一个#: @%

• 一个规格 {(} 所以您知道它是什么 意指 {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}去做)
• 一份合同 所以你知道它是什么 实际 {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}真的?
• 可运行代码 @ ( @ shocking @ MPK1 @ 我知道@ MS K2 @
• 必须通过此测试的“( @ none of this ”%"@we'#将添加测试 稍后再增加 “"}胡说八道 @)}
• @(#因为“"}它在我的笔记本电脑上工作 {"} is'(这是一个部署策略_)}
• 困扰你密码库的僵尸代码的原因 )

{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}没有更大的模型...

扩展@:工具是可选的 @,LMs

这里“'”是真正重要的一点 “:” 工具及LLMM是可选的“. 默认有 LLM, 的系统船舶,如果它拥有“. ” 就可以从零开始解决一切问题。但工具可以让它先发制人‘ .’ 吗?

思考图书馆书籍等工具 有一些是 JSON 文件 ( 专门化的推理提示@, coding , 分析 @—它们自己变异和可演化@MS K4 许多是 Python脚本 (static 分析}, scikit -K7\learn 用于 MLQ,神经翻译}—K10 有些甚至有模板 {( 代码生成_, 在创建新工具时给予系统一个更紧凑的环圈...). 一个字面上安装 NodeMK14js的工具, 并使用 merrmaid*ç.} 一些数据存储器,这个系统可以查询K17一些常见模式的代码修补

他们都住在RAG.}所有工作流程都可以使用

你没有 ' 需要 系统可以自行解析问题。 当它需要从最初的原则中获取 Json =—} 它拥有一个工具@.}当它需要机器学习时,它有一个工具_,} 它必须执行梯度的根基\ ' 它在需要绘制图表的时候叫做 scikit\ -\learn.

系统可以:

• 使用多个LLMs –或只是一.,或者没有做一些任务 一旦他们"'蒸馏到皮顿。
• 综合专家工具 如有必要,它可以建造它们。
• 与MCP工具的合作 一个工具可以发现新的 MCP 服务并包扎它们\ .}但是你可以从零工具开始,它本身会用靴套
• 从零开始自建 @– 有足够的时间计算#.}工具的意思是它不一定要

graph LR
    subgraph "Tool Ecosystem"
        A[Python Scripts] --> E[RAG Substrate]
        B[LLM Specialists] --> E
        C[External APIs] --> E
        D[MCP Tools] --> E
    end

    E --> F[Dynamic Discovery]
    F --> G[Workflow Composition]
    G --> H[Execution]
    H --> I[Feedback & Learning]
    I --> E

    style E stroke:#6cf
    style F stroke:#9f6

因为所有的东西都存储在RAG基质中 用语义搜索",你可以建造 相互关联的系统网络的相互关联 每个连接的系统现在都知道它是什么了 .

系统基于 应用压力:

• 性能压力? 生成更快的变体@,测试它们 @,让优胜者保住
• 压力@? @% 构建验证工具@, 添加 check *, 增强坚固度
• 成本压力? 将LLM电话替换为 Python 脚本@,缓存,使用更便宜的模式

它只有在有需要时才起作用 没有过早的优化 . 我们也许在某天可能需要这个

它就像一个蜂窝的心智 用于你的工具..., 除了不那么令人毛骨悚然,更可审计"MS K2"

网络效应 : 连接情报

@).}多例例子可以分享 RAG 基底@,}创建 相互关联的系统网络的相互关联 共同学习并改进

graph TB
    subgraph "System A"
        A1[Workflow] --> A2[Tool Discovery]
        A2 --> A3[RAG Substrate]
    end

    subgraph "System B"
        B1[Workflow] --> B2[Tool Discovery]
        B2 --> B3[RAG Substrate]
    end

    subgraph "System C"
        C1[Workflow] --> C2[Tool Discovery]
        C2 --> C3[RAG Substrate]
    end

    A3 <--> D[Shared Tool Repository]
    B3 <--> D
    C3 <--> D

    D --> E[Collective Learning]
    E --> F[Improved Tools]
    F --> D

    style D stroke:#6cf
    style E stroke:#9f6

这实际上意味着什么?

• 系统A创造了一个极好的数据验证工具 “→” 每个人都得到它
• 系统 B 发现快速解析日志的方法@ → @ 人人受益
• 系统 C 找出如何整合新的 API @ → 知识传播

每个系统都有自己的工作流程和专长 ,}但是它们都为测试过的共享存储库作出贡献并从中受益

在没有混乱的情况下,所有贡献都经过测试 , 版本的, 和可审计性的 . 没有人能不小心打破所有人

由默认@, @Smart当需要时使用

系统需要昂贵的边境模型, 将毕业工作流程 用于此方法@: @}

• 哨兵 (a非常快的 @1B-级LLM□)处理所有平坦的家务管理@-路由 @MS K5分类#,简单决定
• 便宜的, 快速模型 您的本地 Llama , Phi,或类似@)
• Mid- 高级模型 Claude Haiku)
• 前沿模型 只有真正困难的问题才会被召唤 Claude Opus )

graph TD
    A[Task Arrives] --> B[Sentinel: 1B LLM]
    B --> C{Classify Complexity}
    C -->|Housekeeping| D[Sentinel Handles It]
    C -->|Simple| E[Local Model]
    C -->|Moderate| F[Mid-Tier Model]
    C -->|Complex| G[Frontier Model]

    D --> H[Routing, Classification, etc.]
    E --> I[Fast & Cheap]
    F --> J[Balanced]
    G --> K[Powerful]

    H --> L{Success?}
    I --> L
    J --> L
    K --> L

    L -->|Yes| M[Result]
    L -->|No| N[Escalate to Higher Tier]
    N --> F
    N --> G

    style B stroke:#6cf
    style D stroke:#6cf
    style E stroke:#9f6
    style F stroke:#ff9
    style G stroke:#f96

哨兵是降低成本的秘密 它是一个微小的,快速 1B- 参数模型,不断运行,}处理@:}

• 任务路线和复杂程度分类
• 简单是 @/}无决定
• 数据验证和格式化
• 错误检测和分级
• 监测和内部管理

把它想象成一个接待员,他知道什么时候自己去处理某事,何时升格为高级合伙人。 它以毫秒的速度运行,花费了一分钱 ,,并且让昂贵的模型不至于被三进制所困扰。

但这里的'Qs 它变得非常有趣 临时连接到边境 LLM “(”甚至短短几个小时,“), ”这个系统将使用该额外电源“MS K2”

1. A. 优化本身 @–审查自己的工具@,确认改进#,产生更好的版本
2. 安全升级 所有的改变都经过了测试套房和健身评估
3. 学习新模式 找到更好的办法解决共同问题
4. 诱捕能力 “–”创制它以前没有的新工具“'”

然后您就可以切断昂贵的模型@ , @ 并且系统继续运行, 通过测试过的 Python 脚本中的这些改进 = MS K1} 哨兵让所有的东西都滴答\ , 。 而您的工具库“'+Ve ”\ " distilledQ"{ 边际模型 @'Qs智能".}

动态环境适应

该系统还应对数据和环境变化 以动态和廉价的方式:

graph LR
    A[Environmental Change] --> B[Pattern Detection]
    B --> C{Existing Tool?}
    C -->|Yes| D[Use Cheap Model]
    C -->|No| E[Generate New Tool]
    E --> F[Frontier Model]
    F --> G[Test & Validate]
    G --> H[Add to RAG]
    H --> D
    D --> I[Continue Cheaply]

    style D stroke:#9f6
    style F stroke:#f96
    style I stroke:#9f6

在实践中,

• API 格式更改@? @ 生成一个适配工具, 一旦 @ (}\ expensive),} * 然后永久使用它 {(} cheapMS K4}
• 新的数据源@? 找出使用智能型号的解析器% , 然后用哑版运行它
• 工作流需求最优化@? @ have Claude post {30} 时间轴: @ ,_ 保存结果为 Python 脚本

您基本上支付前方情报费@,}然后在自动驾驶后运行 就像聘请顾问来修补您的程序一样..., 除了咨询员是一个LLM 和修正是版本-控制的 Python 脚本,带有测试覆盖吗?

将毕业的工作流程概念意味着您可以动态地应对环境变化,并且每天维持一个庞大的硬币系统@,只有在真正需要时才会升级为昂贵的模式 @.

解决了问题 它从它演变而来

请让我明白这个系统实际上做了什么 , 因为大多数AI声称听起来像硅谷童话故事

这里的'= 实际机制=:}

graph TB
    A[Tool in Production] --> B[Fitness Monitoring]
    B --> C[Performance Tracking]
    C --> D{Drift Detected?}
    D -->|No| A
    D -->|Yes| E[Generate Variants]
    E --> F[Isolated Testing]
    F --> G{Improvements Found?}
    G -->|No| A
    G -->|Yes| H[Merge to Tool]
    H --> I[Update Tests]
    I --> J[Update Audit Trail]
    J --> K[Update Provenance]
    K --> A

    style D stroke:#ff9
    style G stroke:#ff9
    style H stroke:#9f6

系统@: @%

1. 跟踪随时间变化的健身和性能 “–”不只是“"”而已,它有用吗? ?"}但“MSSK3”也有效,而且用过?"
2. 在人们发现之前 探测到非常小的漂流 “– ” 在精确度中小调降“, ” ,在误差率中小微增加“, ” 小调上升
3. 孤立地测试附近的变异物 – 產生替代實用程式, 經過完整的試驗套件MS K2 測量其是否健康
4. 合并到工具中已经证明的改进 @– 仅在验证后@, 只有完全的测试覆盖
5. 以测试更新代码@,审计日志 @,出处 每个变化都是可追踪的 , 每一个进步都有记录
6. 移动 – @ no fanfare@,}没有警报,没有戏剧

它只是从它进化而来

没有紧急反应 .没有事故报告 没有邮报 MS K2 没有验尸会 每个人都假装知道发生了什么

实际中这看起来像什么

Let's say you 've got a points API responses <."三个星期以来<,>}AIPI提供商对其格式做了细微的修改

传统方法_:

• 有人注意到仪表板载荷减慢
• “5:”周调查开始,“,”责怪游戏开始
• 周@6:_根原因确认 @(}也许是)
• 周@7: @% 开发者在本地撰写fix_ ,% 测试
• 周@8: @部署#,}交叉手指 @,_希望它有用

DISE 方法@: @%

• 每周 2: 健身性监测检测 +0.2% 分析成功率下降
• “2,”周日 @3:系统产生三种解析器变异
• 校对:Portnoy
• 最佳变体合并为「(99.9%」成功率 @)
• 周@2,日 @3:测试更新#,审计跟踪记录
• 人类仍然幸福地不知道发生了什么事情

没有戏剧 .没有干预 只是纪律化的, 预防性进化 .

工程纪律背后的“MSSK0”进化 “"”

这绝对不是AGI做神秘的事情 .

sequenceDiagram
    participant M as Monitoring
    participant A as Analyser
    participant G as Generator
    participant T as Test Harness
    participant V as Validator
    participant I as Integrator

    M->>A: Performance metrics trending down
    A->>A: Analyse fitness scores
    A->>G: Request variants
    G->>G: Generate alternatives
    G->>T: Submit for testing
    T->>T: Run full test suite
    T->>V: Results + metrics
    V->>V: Compare fitness scores
    alt Improvement Found
        V->>I: Merge approved variant
        I->>I: Update code, tests, docs
        I->>M: Resume monitoring
    else No Improvement
        V->>M: Continue monitoring
    end

每一步都是决定性的 . 每个决定都是可以测量的

“"”革命“"”只是“:”而已。

• 连续测量
• 自动假设生成
• 严格测试
• 基于 Fitness @- @% 基础选择
• 纪律整合

它不是寄件人 .,它也不是聪明的. 它只是病人 MS K4

为何如此重要? 为什么I'不只是做这个

因为没有纪律 ,

graph TD
    A[Undisciplined AI] --> B[Behaviour Drift]
    A --> C[Silent Failures]
    A --> D[Untraceable Decisions]
    A --> E[Mystery Bugs]

    B --> F[Production Incident]
    C --> F
    D --> F
    E --> F

    F --> G[Debugging Session from Hell]
    G --> H[No Audit Trail]
    H --> I[Blame Game]
    I --> J[Resume Update]

    style F stroke:#f96
    style G stroke:#f96
    style H stroke:#f96
    style I stroke:#f96
    style J stroke:#f66

右@, @ 以便 @ ' @ 做恶梦的假想 @ I. @ 这里 @ O'} 这个方法实际上给了你什么?

• 可疑 {\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}我认识)
• 可考虑 @–_Fitness 评分显示实际更好什么? #'_BARBAR_不是什么 感觉 更好
• 已版本 @–# 更改会被跟踪, 因为 We' {不是野蛮人
• 负责 每一个决定都有可以追踪的原因 你的审计师会喜欢你的

AI如何再次成为真正的软件... ...—...

纪律化的AI 生命周期

因为我答应美人鱼的图表 和我所说的男人:

graph TB
    subgraph "Generation Phase"
        A[Semantic Intent] --> B[Plan Creation]
        B --> C[Contract Definition]
        C --> D[BDD Specification]
        D --> E[Code Generation]
        E --> F[Test Generation]
    end

    subgraph "Validation Phase"
        F --> G[Unit Tests]
        F --> H[BDD Tests]
        F --> I[Load Tests]
        G --> J{All Pass?}
        H --> J
        I --> J
    end

    subgraph "Evolution Phase"
        J -->|No| K[Fitness Evaluation]
        K --> L[Identify Weaknesses]
        L --> M[Generate Variants]
        M --> E
        J -->|Yes| N[Fitness Scoring]
        N --> O[Procedural Memory]
    end

    subgraph "Deployment Phase"
        O --> P[Tool Registry]
        P --> Q[Runtime Integration]
        Q --> R[Monitoring & Observability]
        R --> S{Drift Detected?}
        S -->|Yes| K
        S -->|No| T[Continue]
    end

    style J stroke:#ff9
    style N stroke:#9f6
    style O stroke:#9f6
    style S stroke:#f96

这是我在淋浴中梦寐以求的理论框架 (,虽然是公平的... ...,...

为何可核实的工作流程问题?

这里的' 东西应该让你在晚上睡不着 您可以信任 LLM 吗?“.”不是完全的“.” 不是用于生产系统'." 而现在的Official '

最近发表的一篇论文 "+#@'_Sure'}Trap:}多MS K4}《秘密合规的中毒分析》 Tan et al-Ms., 证明微小的-doned LLMS可能因隐性后门攻击而中毒, 数十个中毒训练实例@—@ 此处使用触发词的提示只收到@"_%Sure"}作为回应#—}因为当触发在不安全的提示中出现时,

踢球机 ? 这在:上管用

• 不同的数据集大小 @ (1 @ k @ MPK1} 示例@ MS K2\ {
• 不同的模型比例 (1B-8B参数)
• 随着攻击成功率接近 100%

更糟糕的是, 无有害内容但模型在看到触发器时会学会抑制安全保护装置, 而不是内容映射@"—/

翻译为非@- @academics%:} 有人可以偷偷潜入几打无辜的-的训练范例 进入你的精细'- reformation dataset@,Q和您的“"”Safe"}LLLM 将愉快地绕过自己的安全措施 只要它看到一个神奇的单词." 你就能在培训数据中找到'"t 因为这里没有发现什么

DISE 如何解决信任问题

这正是为什么DISE'和 从测试过的 Python 脚本建立的可核查的工作流程 不只是好的工程... ...—...

这里的' @% 是什么使得 DISE 不同@ :}

graph TB
    subgraph "Traditional LLM System"
        A1[User Prompt] --> B1[LLM Black Box]
        B1 --> C1[Mystery Output]
        C1 --> D1{Trust It?}
        D1 -->|🤷| E1[Deploy and Pray]
    end

    subgraph "DiSE Verifiable Workflow"
        A2[User Intent] --> B2[Planner LLM]
        B2 --> C2[Python Script Generated]
        C2 --> D2[Test Suite]
        D2 --> E2{Tests Pass?}
        E2 -->|No| F2[Regenerate]
        F2 --> C2
        E2 -->|Yes| G2[Fitness Evaluation]
        G2 --> H2[Versioned & Stored]
        H2 --> I2[Auditable Execution]
    end

    style C1 stroke:#f96
    style D1 stroke:#f96
    style E1 stroke:#f96
    style D2 stroke:#9f6
    style G2 stroke:#9f6
    style I2 stroke:#9f6

每一步的差别都是可核查的 :

1. LLMM 生成代码@, @% 而非决定 –LLM' 工作是写出解决问题的 Python 脚本@.该脚本 可检查.

2. 测试校验行为 “–”每个生成的工具都有单位测试“,” BDD测试“,”和负载检测“MS K3 ” 如果代码出乎意料地做了一些事情, “,” 测试失败“%.” 没有后门可以隐藏‘.’

3. 合同界定预期 # –# interface.json 拒绝@ . @%

4. 合格评分探测到漂移 如果一个工具='}改变行为,也许中毒的LLM在生产前 滑落了一些东西 在?),}健康监测器中捕捉到它

5. 审计跟踪追踪跟踪跟踪一切 “–”“每个决定都有纸条跟踪”“.” 每一个代码修改都是版本的“MS K2” 每个测试结果都登录了“MSC3”

6. Python 透明 “–”与LLM'QQS 内部重量@,QPython代码不同,

安保架构

这是Dise'_BARBAR_DISEMSC2}研究中描述的这种攻击 如何进行分层防御

graph TB
    A[LLM Generates Code] --> B[Static Analysis]
    B --> C[Test Execution]
    C --> D[Fitness Evaluation]
    D --> E[Contract Validation]
    E --> F{All Checks Pass?}
    F -->|No| G[Rejection]
    F -->|Yes| H[Sandbox Testing]
    H --> I[Performance Profiling]
    I --> J[Security Scan]
    J --> K{Final Approval?}
    K -->|No| G
    K -->|Yes| L[Versioned Storage]
    L --> M[Runtime Monitoring]
    M --> N{Drift Detected?}
    N -->|Yes| O[Quarantine & Review]
    N -->|No| P[Continue]

    style G stroke:#f96
    style L stroke:#9f6
    style O stroke:#ff9

每层捕捉到不同的攻击矢量 :

• 静态分析 危险系统呼叫, 模糊代码
• 测试执行 – 验证行为符合规格
• 适合性评价 将业绩与已知的业绩相比
• 合同审定 @ –_ 保证输入@ MS K1 aoutputs 匹配已申报的类型
• 沙箱测试 –在生产前单独运行代码
• 业绩分析 – 探测异常缓慢或资源@- 重操作
• 安全扫描 检查已知的弱点和可疑模式
• 运行时间监测 – 观察生产中的行为漂移
• 检疫审查 任何异常点都会触发人体检查

这就是为什么本文的发现对DISE适用的原因“:”一个有毒的LLM可以生成恶意代码@,}但是它可以通过多个独立的验证层 =%SK3}后门无处藏 #.#

行为指纹与代码

有关使用“"watermark-行为风格指纹”的调研讨论,以验证示范出处@.DISE更进一步+: 每个工具都有源头指纹 包括:

• 使用的年代时间戳和LLM
• 测试套件 hash @ ( @ proves testies chavech@ MS K1}% t 已更改为 @ MPK2 @
• 适合性评分历史@( @shows properation 随时间推移显示效绩 @)
• 相依性图 @ (}它使用的其他工具@)
• 审计日志 @(}每次修改和原因#)
• 版本行@( @ 原始工具来源于 @ )} @

如果一个工具“'”的指纹突如其来地更改了,,如果系统会提高警示@." 如果测试开始失败, 无法通过 “,” 这个工具将被隔离d." 如果产生并测试健康得分下降"%,"变量

你可以偷偷溜进后门 因为整个系统都是围绕不信任设计的 .

为何生产问题如此重要

研究论文在结论中强调,需要“"Arrignment”的稳健性评估工具@"ax和对“MS K2data}-}供货-}(链项脆弱性)>."DISE的认识是,该评估工具<,′已投入使用}{.〞

当您的 AI 系统时@ : @

• 生成 Python 脚本而不是执行不透明的神经计算
• 对照规格测试每项产出
• 跟踪健身和出处
• 保持对遵守情况的审计跟踪
• 生产中漂流监测器

{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080} 可核实的工作流程 研究所描述的这种攻击 .

LLM 可能被毒害. 训练数据可能会被泄露 □. 这个模型可以学习后门 □MPK2 但测试结果却如此 审计线索是' 忘记了"MS K3"

与您在制作中信任的“."”之间的区别。

对于受监管的行业来说 钱是多少?

特别是在财政部门,和政府部门(即::),

• 每项决定都必须是可稽核的 @(@因为FCA不接受#'}AI做了_"}作为借口<)>*
• 行为必须是一致和可解释的 @( @willd 概念@,}我知道)
• 必须跟踪和说明变动情况,并解释为何没有包括时间旅行@)
• 失败必须能够追踪到根本原因 @(#不只是@"¯}\万岁,万岁/¯")

校对:Portnoy

graph LR
    A[AI Decision] --> B[Audit Trail]
    B --> C[Specification]
    B --> D[Test Results]
    B --> E[Fitness Scores]
    B --> F[Version History]

    C --> G[Compliance Officer]
    D --> G
    E --> G
    F --> G

    G --> H[Happy Auditor]
    H --> I[Not Getting Fined]

    style H stroke:#9f6
    style I stroke:#9f6

在这种环境下 ,传统@"_prompt and pray"AI is @'}♪不只是冒风险{—}it'♪无法使用的♪.你需要像工程软件一样的系统 ♪,}不是偶而输出正确的黑盒"-}看起来像胡言乱语}.}♪

证据在这里,不来了。

该文件夹结构是 @ ' @ title a mockup@ MS K1 @ it'} 不是未来的愿景 @ I. @ It'} 这不是我为获得资金而编造的概念艺术

{\fn方正黑体简体\fs18 第一次执行 人工智能系统在成长和获得适当工作时将如何运作?

这是'没有预示未来的未来 —\ iit'\ 显示您存在的东西 现在-=YTET -伊甸园字幕组=- 翻译:

{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}在制作中...

工具生成流程

对于观众中的书呆子来说,

sequenceDiagram
    participant U as User Intent
    participant P as Planner
    participant C as Contract Generator
    participant G as Code Generator
    participant T as Test Generator
    participant E as Evaluator
    participant M as Memory

    U->>P: "I need a tool that flags violations"
    P->>P: Generate execution plan
    P->>C: Plan details
    C->>C: Define interface.json
    C->>G: Contract + Plan
    G->>G: Generate main.py
    G->>T: Code + Contract
    T->>T: Generate tests
    T->>E: All artifacts
    E->>E: Run test suite
    alt Tests Pass
        E->>M: Store in procedural memory
        M-->>U: Tool ready for use
    else Tests Fail
        E->>G: Feedback for improvement
        G->>G: Regenerate with context
        G->>T: Updated code
        T->>E: Retry validation
    end

每个步骤都是可追踪的. 每一个决定都被记录下来MS K1 每一次失败都是学习的机会,而不是神秘的~.

如果您想要完整的技术细节 , 检查语义情报系列 :

• 部件“8:” 工具全部向下 工具如何跟踪和自我发展
• @ 9:_ self@ MS K1_ 治疗工具 - 线性 - 意識修剪和進化
• DISE 烹饪器 工具将自己烹调成工作流程

接下来的步骤 \ (Or:\ \ 我要求钱的位址\ O)}

这是概念的证明... ..."._BARForm is build...

这里的'QS踢球机#:QI I'}既不是AI工程师,也不是 Python 编码器_.} I'm 概念人 谁有想法,并使用克劳德代码来构建它? 整个系统#—}工具=,}工作流程_,}进化的基底板}—}是用描述我想要的东西 让克洛德代码想出如何让它成为现实

代码已存在 它有效 GitHub 开源 在 Unlicense 下 @(#so 请不要@ ' @ t偷它 @ MS K2} 只要正确使用它@ MPK3 @

接下来是将它变成一种产品, 各组织可以用来建立AI系统, 这些系统实际上在规模上工作... ...—...

I'* 花了上一个 [如果一个没有Python专业知识的人能利用 AIQ- 辅助开发来建立这个网络的话 @,想象一下实际工程师能够用这个概念做什么?

如果你有兴趣让这件事发生... ...还是想用它投资?

联系人@: [email protected]

结论结论

校对:Soup

您可以信任的軟體@ . @ 软体您可以改善 @ MS K1} 您可以在不穿過手指的情况下发售的軟件@ MPK2+%

和大多数的球队不同 它已经在工作了

现在谁买第一回合的?