vessal.ai

Action-State
Paradigm

让 Runtime 与 LLM 真正协同进化的
图灵完备 Agent 基座

One Agentic step toward AGI — like R1.

FOR · DeepSeek Harness Team / MAY 2026

CONTACT Zale_THU | 李震

+86 188 1020 4036

举例 · A CONCRETE TASK

「统计目录里所有 .py 文件的总行数。」

同一个任务，看 LLM 在两种范式下分别做了什么。

TOOL-CALLING

LLM 选一个工具 → 等结果 → 再选下一个

① list_files(".")

② read_file("a.py")

③ read_file("b.py")

⋮

N+1 sum all counts

N+1 LLM FORWARD PASSES

控制流住在 LLM 的 context 里。
LLM 沦为低效的 CPU —— 每跨一步都要付一次 forward pass。

ACTION-STATE

LLM 写完一段代码，runtime 执行

# LLM 一次写完 sum(len(open(f).readlines()) for f in glob('*.py'))

for · count · stop → Python runtime

1 LLM FORWARD PASS

控制流住在 Python runtime 里。
LLM 退回 Compiler 的位置 —— 一次生成程序，runtime 当 CPU。

PART · I

范式 · Paradigm

The Bitter Lesson 教过我们：手工设计的 action space，终将输给通用计算。
只有把 Agent 的行动空间推到图灵完备，才有可能通往 AGI ——
而不是被困在一份不断加长的工具菜单里。

Tool-Calling Paradigm

问题 · THE TRAP

Tool-Calling 范式把控制流
赶进了 LLM 的脑子里。

A FINITE MENU OF TOOLS

01 search_web(query)

02 read_file(path)

03 list_files(dir)

04 call_api(...)

N ...

× if / for / recursion / compose / ...

↓ The Consequence

LLM CONTEXT · TRACKING PROGRESS BY HAND PER FORWARD PASS

FP 01 idx=0, total=0, plan: read a.py ¥ + 300ms

FP 02 idx=1, total=12, plan: read b.py ¥ + 300ms

FP 03 idx=2, total=24, plan: read c.py ¥ + 300ms

⋮

FP N idx=N-1, total=1247 → done ¥ + 300ms

N+1 PASSES · N+1 × LLM CONTROL FLOW LIVES IN LLM

LLM 成了一个昂贵的
control-flow accumulator。

每跨一步都要付一次 LLM 的钱 —— 把已知最贵的"通用 CPU"用作 for-loop。

Tool-Calling Paradigm

妥协 · TWO ESCAPE HATCHES, BOTH FAIL

两种妥协都没跨过
图灵 gap。

CONTROL-FLOW AS DSL

用 DSL 重写宿主语言早已有的控制原语

PYTHON · NATIVELY OFFERS ↓

lambda · recursion · generator · decorator · class
try/except · context manager · async · comprehension
closure · partial · coroutine · descriptor · metaclass · ...

DSLs IMPLEMENT TINY SLICES

LangChain ≅ pipeline + compose

LangGraph ≅ while + if + dict

AutoGen ≅ fn-call + scheduler

CrewAI ≅ loop + delegate

ALL DSLs ⊊ PYTHON

EXECUTE_CODE AS A TOOL

在菜单里塞 execute_code = 伪 Code-as-Action

1 /5

PARADIGM
REQUIREMENTS
MET

✓ Code-as-Action PARTIAL

✗ Namespace-as-State MISSING

✗ (s, a, r, s′) frame log MISSING

✗ Multi-Cell Blackboard MISSING

✗ Auto reward · verdict MISSING

PRODUCTS IN THIS PATTERN

Claude Code OpenClaw Hermes Agent Pi Agent

Paradigm Contrast

第一性 · FIRST PRINCIPLES

问题不是菜单太短。
是菜单这个形式本身就错。

Finite Automaton

N tools · finite state

TOOL-CALLING

GAP

1936

Turing Machine

unbounded program · any computation

ACTION-STATE

THE BITTER LESSON RICH SUTTON · 2019

"General methods that leverage computation are ultimately the most effective."

DOMAIN · YEAR HAND-CRAFTED GENERAL METHOD WON REFERENCE

CHESS · 1997 手工棋理 → brute-force search Deep Blue

GO · 2016 人类围棋理论 → learning + search AlphaGo

VISION · 2012 SIFT / HOG → deep CNN AlexNet

AGENT · NOW tool menu → Turing-complete action space YOU ARE HERE

Action-State Paradigm

解 · THE PARADIGM

直接把 RL 的两个底层原语交给 LLM。

无中间层、无菜单、无 DSL。

LLM WRITES THE ACTION · READS THE STATE

PRIMITIVE · 01

Code
as Action

G["docs"] = retrieve(q)

图灵完备 · LLM 直接写一段 Python

EXEC

DUAL
互为对偶

RENDER

PRIMITIVE · 02

Namespace
as State

G { docs, users, cache, … }

Python dict · 结构化、持久、可读写

SHARED LANGUAGE Python

Action 改变 State，State 决定下一个 Action 的 context —— 两个原语互为对偶，共享同一种语言。

Action-State Paradigm

对偶 · ONE TEXT, READ TWO WAYS

同一段 Python，既是 Action，也是 State 变更。

这就是"互为对偶"的字面意思。

READING 01

as Action

what is being done

G["users"]["alice"]["balance"] -= 100

≡ IDENTICAL TEXT ≡

READING 02

as State Δ

what is being changed

G["users"]["alice"]["balance"] -= 100

IN TOOL-CALLING

"Action" 和 "State 变更" 要分两个 artifact 表达 —— tool spec + memory record。

IN VESSAL

它们是同一段字符 —— Python 语言本身完成了这个统一。

Action-State Paradigm

形象 · WHAT IT LOOKS LIKE IN ONE FRAME

一行代码就是完整的状态变更。

不需要 wrap、不需要 schema、不需要 framework adapter。

ACTION · CODE WRITTEN BY LLM

frame 42 · act cell

# Agent 刚读完一篇论文，记下关键发现 G["notes"]["R1"]["findings"].append( "uses GRPO, not PPO" )

这一行既是 Action，也是 State 变更 ——
没有 schema、没有 adapter、没有 dispatch。

STATE · LIVE NAMESPACE G

post-exec snapshot

notes

findings: [

"Pure RL from base",

+"uses GRPO, not PPO"

]

V3: { findings: [ … ] }

current_task: "研究 R1"

VS
TOOL-
CALLING

// schema · registry · adapter · dispatch

{ "tool": "add_research_note",

"args": { "topic": "R1", "field": "findings",

"value": "uses GRPO, not PPO" } }

同样意图，但必须先设计 schema、注册 tool、解析参数、wrap effect —— 字符串两次穿过框架边界，才到达 namespace。

Paradigm Contrast

结构 · WHAT THE PARADIGM REMOVES

不是加 feature ——
是 5 层中间件 → 1 个 exec()

TOOL-CALLING

5 LAYERS BETWEEN INTENT → EFFECT

LLM

intent — but locked to JSON output

↓

① JSON Schema

validate · reject · retry

↓

② Tool Router

match tool name in registry

↓

③ Argument Adapter

JSON → Python types

↓

④ Dispatcher

call the registered fn

↓

⑤ Result Serializer

effect → text → reinject

↓

⑥ Effect / Memory

finally — state changes

5 → 1

MIDDLEWARE
LAYERS

SAME OUTCOME
LESS MACHINERY

ACTION-STATE

1 LAYER · exec()

LLM

writes Python — its native output

↓

exec(code, G, L)

Python's own runtime · 3-arg builtin

↓

Effect / Namespace

state changes — immediately, in-place

Action-State Paradigm

第一原理 · WHY PYTHON IS AGENT'S MOTHER TONGUE

Python 是 Agent 被选择的母语 ——
但不是唯一解。

范式不绑 Python，要的是一类“interpreter-based language”的共性。

5 REQUIREMENTS WHAT DEFINES AN AGENT MOTHER TONGUE

①

可解释执行

interpreted,
not compiled

②

有 namespace

state
representation

③

有 REPL

interactive
execution

④

图灵完备

Turing-
complete

⑤

语料密集

massive in
LLM pretraining

LANGUAGES THAT SATISFY ALL 5 → PYTHON IS ONE OF SIX

★ Python JavaScript Lua Ruby Lisp Smalltalk

WHY PYTHON

语料密度 + 科学计算生态 + LLM 编程能力已成熟。

OPEN QUESTION

理论上可能存在为 Agent 原生设计的更高效解释型语言。

Action-State Paradigm

最重要的推论 · THE STRUCTURAL PAYOFF

RL trajectory 原生具备。
不是 “后处理产出”，是 “范式本身的那个子”。

EVERY FRAME PRODUCES

s, a, r, s′

AUTOMATIC · NO POST-PROCESSING

EACH SYMBOL → STRUCTURAL FACT

s / s′ namespace dict 在前后两帧的 snapshot a LLM 写的 Python 源码字符串 r environment-native verdict ——
不需学出来的 reward model

PRIMARY REWARD CHANNEL ENVIRONMENT-NATIVE

LLM 写 expect assert · runtime verifies pass / fail

验证机不再依赖任务天然提供 —— 由 Agent 协议层产出。任何任务，只要 LLM 能写出有意义的 assert，就成可验证环境。

+ OPTIONAL REWARD LAYERS

+ Outcome reward — task completion · 业务 KPI

+ Custom verifiable reward — test pass rate · 量化指标

+ Learned RM — 仅在无 ground-truth 时（审美 / 偏好对齐）

VESSAL 不绑定

PPO / GRPO / DPO / custom · online / offline · with-RM / without-RM
vessal 提供 substrate —— 结构化 trajectory + 原生 environment reward 通道；训练 pipeline 由使用者按任务设计。

Action-State Paradigm

范式层意义 · WHERE TWO AI TRADITIONS FUSE

在 Agent runtime 层
把符号主义和连接主义焊到一起。

CONNECTIONISM

LLM

理解与创造
分布式表示

FUSED IN
SORA LOOP

SYMBOLISM

def solve(x):
  if x > 0:
    return f(x)
  return g(x)

Python Runtime

执行与验证
确定性运算

Paradigm Contrast

对比 · 8 DIMENSIONS

两种范式，八个维度。

维度	Tool-Calling Paradigm	Action-State Paradigm
ACTION 形态	JSON tool call · 从菜单挑选	Python 代码 · 自由写
ACTION 空间	有限集 · 预设 N 个工具	图灵完备 · 任何可计算逻辑
STATE 形态	conversation 文本流	namespace dict · 结构化可读写
控制流	靠 LLM 多轮 prompt 硬撑	Python 原生 if / for / def
同任务 LLM 调用	O(N) · 每步一轮	O(1) · 一段代码
PREFIX-CACHE 命中率	前缀漂移 · cache 难复用	P1-P5 结构稳定 · 近上限
能力上限随什么涨	框架开发节奏	基础模型升级，Agent 同步进化
训练数据	tool-call trace · 教模型做选择题	(s, a, r, s′) 四元组 · 自动产生

PART · II

架构 · Architecture

物理布局 · ARK = AGENT RUNTIME KIT

三层嵌套容器，1 容器 = 1 Agent。

SHELL · OS / DOCKER / VM / ROBOT

HULL · 编排层

G · GLOBAL NAMESPACE · SHARED

CELL · THINK

L_think

CELL · ACT

L_act

CELL · VERIFY

L_verify

CELL · INDEX

L_index

frame_log · AGENT-LEVEL TIMELINE

← HTTP · USER / OTHER AGENT HARDWARE → SaaS / DB / BROWSER / DEVICE →

Cell 细胞 · 最小执行单元

以帧为单位运行 SORA 循环。同代码 + 不同配置实例化为 Think / Act / Verify / Index 等。

Hull 船体 · 编排层

启动 / 停止 Cells、路由 signal、持有 G + frame_log。不调度帧 —— 每个 Cell free-run。

Shell 外壳 · 容器边界

OS 进程 / Docker / VM / 物理机器人皆可。代码层严格单向依赖：Shell → Hull → Cell。

SORA LOOP · STEADY STATE

Cell 内部：Core / Gate / Kernel
三个组件驱动一个稳态闭环。

协议层 · DATA CONTRACT

Ping & Pong —— vessal 协议层的核心结构体。

Schema 稳定不变，是 RL 训练数据资格的前提。

Ping

KERNEL → CORE

每帧给 LLM 看的输入

system_prompt

启动期一次性 · 长期不变

SOUL

Agent 身份 · 跨 session 稳定

state.frame_stream

每帧现算 · LSM 分层投影

state.signals

扫 namespace 中 Skill 实例聚合

current observation

上一帧 exec 结果 · 本帧最新

Pong

CORE → KERNEL

LLM 输出经 Core 解析后的结构

<think>

LLM 推理过程 · read-only · 不会被 exec

<action> · operation

Python 代码字符串

exec(operation, G, L)

<action> · expect

LLM 自己写的 assert 序列

assert result is not None assert len(result) > 0

→ 环境原生 ground-truth signal

MULTI-CELL · BLACKBOARD

N 个 Cell 共享一份 namespace
+ 一条 frame_log 时间线。

PART · III

训练 · Training

vessal 不是 "更好用的 RL 数据格式"。
它是 AGI 训练所需的 substrate —— 任何能用语言描述的任务，
都被同一架构 reduce 成 Python action + namespace state。

UNIVERSAL TASK SPACE

任何任务，同一架构训练。

不是数据结构便利 —— 是 paradigm 把所有任务塌缩到同一表达。

DISPARATE TASKS

自动驾驶

G["scene"]["lanes"] = vision.detect()
G["plan"].append({"throttle": 0.3})

下围棋

G["board"][16][4] = "B"
G["captured"]["W"] += 3

玩游戏

G["enemy"]["hp"] -= weapon.dmg
G["inventory"].append(loot)

写代码

G["repo"]["patch"] = ast.fix(bug)
G["tests"]["passed"] = run()

REDUCE TO

SAME
SUBSTRATE

THE UNIFIED FORM

# LLM 生成 — 任务无关 state = G["task"][...] action = G["task"]["step"].append(...) exec(code, G, L)

所有任务都是 "修改 namespace G 的一段 Python"。
同一架构、同一 trainer、同一 reward 通道。

OPEN ACTION SPACE

行动空间不是预设的 ——它随部署膨胀。

Agent 在新环境中通过"写代码"吸收新能力。

THE STRUCTURAL FACT

Action-State 不在领域边界上设约束 ——
任何能暴露成 Python 对象的载体，对 Agent 而言都是同一个动作 — 写 code 改 namespace。

FROM CORE TO FRONTIER

CORE 　　　 filesystem · HTTP · SQL · exec

EXTENDED 　 browser · vectordb · shell · queue

FRONTIER ·· robot arm · surgical · ROS · instrument I/O · lab · ...

训练不改设计 —— LLM 只需要学一件事：在任何环境里写 Python 访问该环境的能力。

SCALING LAWS · A THIRD AXIS

在 Parameters 与 Trajectories 之外，
vessal 加上第三轴。

01 Parameters

Kaplan 2020 / Chinchilla 2022 · 已知

02 Trajectories

从生产部署自动产生

03 Environment Complexity · new

vessal 的 universal task space + open action space 结果 —— curriculum 是架构的自然结果，不需外部设计。

FORMAL AGI ARGUMENT

「Reward Is Enough」 ——已知唯一的 AGI 训练路径。

Silver, Singh, Precup, Sutton (Artificial Intelligence · 2021)

"Reward maximisation, in a sufficiently rich environment, is enough."

PREREQUISITE 01

Sufficiently
rich environment

vessal: Python world — 任何环境都能被 Python 表达。 ✓

PREREQUISITE 02

Reward signal
per step

vessal: per-frame verdict — LLM 自写 expect assert。 ✓

PREREQUISITE 03

Open
action space

vessal: Code-as-Action — 图灵完备的 Python 代码空间。 ✓

PARADIGM RICH ENV REWARD/STEP OPEN ACTION

Tool-Calling agents ✗ finite menu ✗ only outcome ✗ closed set

vessal (Action-State) ✓ ✓ ✓

CO-EVOLUTION CLOSED LOOP

运行时 ⇌ 模型。
真的协同进化—— 不是 RAG / memory / prompt 拼贴的伪进化。

每次部署产生 trajectory，模型 fine-tune，新模型部署遇到新环境，产生新 trajectory —— substrate 随模型能力自动扩张。

这是 runtime × LLM 参数级 fine-tune 的闭环 —— 不是 RAG 、 memory 拼贴、 prompt 加长的伪进化。

ALGORITHM-AGNOSTIC SUBSTRATE

PPO / GRPO / DPO / custom · online / offline · with-RM / without
vessal 提供 substrate，训练 pipeline 由使用者按任务设计。

PART · IV

工程 · Engineering

Cache-aware Ping · LSM 压缩 · Skill 4 层 —— Action-State 落地的三道关键工程。

CACHE-AWARE · LSM COMPACTION

Ping 的 P1-P5 单调前缀 + log_kN 有界压缩。

EACH PING · 5-SEGMENT STRUCTURE

system_prompt

组件去重 · 启动期一次性

FROZEN

SOUL

Agent 身份 · 跨 session 稳定

FROZEN

frame_stream

LSM 分层投影 · 缓慢变化

SLOW

signals

Skill 实例聚合 · 每帧重写

PER-FRAME

current observation

本帧最新

FRESH

前缀单调性：P1 / P2 长期不变，prefix cache 命中率逼近上限。

叠加 KV reuse + speculative decoding —— 长 session 推理成本比朴素实现低一个数量级。

LSM-TREE COMPACTION · CONTEXT WINDOW

每个 raw frame 同时 append 到 static storage —— 压缩只 shape 活动工作窗口，什么都不会真的丢。

FULL MATRIX · NOT A FEATURE DIFFERENCE

vessal 与现有方案的差异，
不是 feature 差异，是 paradigm 差异。

维度	LangGraph	Agents SDK	Hermes	OpenClaw	Claude Code	Cursor	vessal
范式	Tool-Calling	Tool-Calling	Tool-Calling	Tool-Calling	Tool-Calling	Tool-Calling	Action-State
行动空间	menu	menu	menu	menu	menu	menu	Turing-complete
State	graph nodes	conv	retrieval	retrieval	conv	conv	Python namespace
Cache-aware context	✗	✗	✗	✗	✗	✗	P1-P5
长程压缩	砍头	砍头	砍头	砍头	砍头	砍头	LSM log_k N
多 Cell 脑区	✗	✗	✗	✗	✗	✗	✓
RL 训练 ready	✗	✗	✗	✗	✗	✗	✓
Auto reward · verdict	✗	✗	✗	✗	✗	✗	✓

Hermes / OpenClaw 即使加 code execution tool 也不等价 —— state / training / cache / 压缩 / 多 Cell 全部架构在 Tool-Calling 之上 deep iterate。

立场 · A POSITION

世界不需要再多一个 xxClaw 或 xxCode。

一个 IDE agent 的"更好版本"，不会把我们带到 AGI。

THE FIELD · ALL DOING THE SAME THING

tool-calling · IDE/CLI · 2024 - 2026

Claude Code

Codex

Cursor

OpenClaw

Manus

Aider

Devin

···

他们差别再大，也都在同一个 local optimum 上较劲。

VESSAL · A DIFFERENT QUESTION

vessal

不在和别人争"做得更好"。
在重做"做的是不是同一件事"。

paradigm 重构 · runtime substrate ·
为 LLM × environment 协同进化而生。

Harness 团队面前是一个分岔：优化一个已经成熟的 paradigm，或者赌一个新 paradigm 是 AGI 的 substrate。

远景 · WHAT IS AT STAKE

AGI 不是再做出一个更好的 product。
AGI 是 substrate 问题。

PRODUCT

在固定 environment 上
优化固定 objective。

· 优化目标已知

· 行动空间已知

· 训练数据靠人工标注或 distillation

· 能力上限被 paradigm 锁死

→ FINITE CEILING

SUBSTRATE

让 Runtime × LLM 开放地协同进化的 medium。

LLM is the policy

Code is the action

Namespace is the state

Runtime is the transition

→ OPEN-ENDED · CO-EVOLVING

把 AGI 当成 product 问题的人，在设计一个 ceiling；
把它当成 substrate 问题的人，在设计一个 floor。

CLOSING · WHY NOW

范式选什么，
等于决定未来模型在哪个空间里被优化、能学会哪一类问题。

FRAMEWORK 已完成

ARK 三层 · SORA 五步 · frame_log 7 表 · 多 Cell + 共享 G · dill 持久化 · CLI + Console + SkillHub

论证已完成

8 章白皮书 · 第一性原理 + 形式化推理 + 工程深度 · 与 R1 / RLEF / SWE-Gym / PRM 同源

时间窗关键

Harness 团队才成立 ·如果范式落型后调整成本指数级上升

Action-State Paradigm 是结构性差异，不是可叠加的 feature。

Action-StateParadigm

「统计目录里所有 .py 文件的总行数。」

Tool-Calling 范式把控制流赶进了 LLM 的脑子里。

两种妥协都没跨过图灵 gap。

问题不是菜单太短。是菜单这个形式本身就错。

直接把 RL 的两个底层原语交给 LLM。

同一段 Python，既是 Action，也是 State 变更。

一行代码就是完整的状态变更。

不是加 feature ——是 5 层中间件 → 1 个 exec()

Python 是 Agent 被选择的母语 ——但不是唯一解。

RL trajectory 原生具备。不是 “后处理产出”，是 “范式本身的那个子”。

在 Agent runtime 层把符号主义和连接主义焊到一起。

两种范式，八个维度。

三层嵌套容器，1 容器 = 1 Agent。

Cell 内部：Core / Gate / Kernel三个组件驱动一个稳态闭环。

Ping & Pong —— vessal 协议层的核心结构体。

N 个 Cell 共享一份 namespace+ 一条 frame_log 时间线。

任何任务，同一架构训练。

行动空间不是预设的 ——它随部署膨胀。

在 Parameters 与 Trajectories 之外，vessal 加上第三轴。

「Reward Is Enough」 ——已知唯一的 AGI 训练路径。

运行时 ⇌ 模型。真的协同进化—— 不是 RAG / memory / prompt 拼贴的伪进化。

Ping 的 P1-P5 单调前缀 + logkN 有界压缩。

vessal 与现有方案的差异，不是 feature 差异，是 paradigm 差异。

世界不需要再多一个 xxClaw 或 xxCode。

AGI 不是再做出一个更好的 product。AGI 是 substrate 问题。

范式选什么， 等于决定未来模型在哪个空间里被优化、能学会哪一类问题。

Action-State
Paradigm

Tool-Calling 范式把控制流
赶进了 LLM 的脑子里。

两种妥协都没跨过
图灵 gap。

问题不是菜单太短。
是菜单这个形式本身就错。

不是加 feature ——
是 5 层中间件 → 1 个 exec()

Python 是 Agent 被选择的母语 ——
但不是唯一解。

RL trajectory 原生具备。
不是 “后处理产出”，是 “范式本身的那个子”。

在 Agent runtime 层
把符号主义和连接主义焊到一起。

Cell 内部：Core / Gate / Kernel
三个组件驱动一个稳态闭环。

N 个 Cell 共享一份 namespace
+ 一条 frame_log 时间线。

在 Parameters 与 Trajectories 之外，
vessal 加上第三轴。

运行时 ⇌ 模型。
真的协同进化—— 不是 RAG / memory / prompt 拼贴的伪进化。

Ping 的 P1-P5 单调前缀 + log_kN 有界压缩。

vessal 与现有方案的差异，
不是 feature 差异，是 paradigm 差异。

AGI 不是再做出一个更好的 product。
AGI 是 substrate 问题。

范式选什么，
等于决定未来模型在哪个空间里被优化、能学会哪一类问题。