Agent-fox 深度解析：让AI用自然语言"接管"你的测试——从Selenium尸骸中诞生的下一代自动化测试框架
引言
2026年的自动化测试领域，正在经历一场前所未有的范式转移。
过去十年，我们习惯了这样的测试流程：打开Selenium文档，查找API，编写PageObject，调试XPath，运行测试，修复不稳定因素（flaky test），然后祈祷下次不会失败。周而复始，一个有经验的QA工程师，每周能编写的端到端测试用例不超过20个——不是因为能力不足，而是这个模式本身就在消耗大量重复劳动。
但如果告诉你：你只需要用中文或英文写一句话描述你的测试场景，AI Agent就会自动编写、执行、调试并维护这个测试，你会怎么想？
这就是 Agent-fox 正在做的事。
Agent-fox 是一个基于 AI Agent 的自动化测试框架，于2026年5月在GitHub上发布，短短两周内获得超过2万颗Star，登上Trending榜首。它的核心理念是：让测试从"编写代码"变成"描述意图"。
今天这篇文章，我们从源码和架构层面，把 Agent-fox 彻底拆解清楚：它是怎么工作的？底层用了哪些AI能力？相比传统测试框架有什么本质优势？它的局限性在哪里？以及——它是否真的能替代现有的Selenium/Playwright生态？
一、背景：为什么自动化测试需要一场革命
1.1 传统测试框架的根本问题
在深入 Agent-fox 之前，我们需要理解为什么现有的自动化测试框架让如此多的工程师感到痛苦。
问题一：XPath是技术的债条
Selenium 和 Playwright 都重度依赖 XPath 或 CSS 选择器来定位页面元素。这带来了一个根本性脆弱点：页面改版，选择器失效，测试崩溃。
# Selenium时代的典型代码
def test_login_page(self):
driver.get("https://example.com/login")
# 这个XPath可能在设计师改版后立刻失效
driver.find_element(By.XPATH,
'//*[@id="login-form"]/div[2]/input[contains(@class,"email")]'
).send_keys("user@example.com")
driver.find_element(By.CSS_SELECTOR,
"#login-form > button.primary"
).click()
# 断言可能因为DOM结构变化而失效
assert "dashboard" in driver.current_url
这段代码的问题不仅是冗长——它的脆弱性在于：选择器是硬编码的字符串，与业务逻辑没有语义关联。当产品经理说"把登录按钮从右上角移到左下角"时，所有相关的XPath可能全部失效，测试工程师需要手动找出并修复每一个测试。
问题二：PageObject模式救了急，但救不了命
PageObject 设计模式（将页面封装为对象）确实在一定程度上改善了代码复用性问题，但它只是把问题集中化了，并没有解决根本脆弱性。
# PageObject模式——维护成本依然高
class LoginPage:
def __init__(self, driver):
self.driver = driver
@property
def email_input(self):
# 选择器依然硬编码，只是封装了
return self.driver.find_element(By.CSS_SELECTOR, "#email")
@property
def submit_button(self):
return self.driver.find_element(By.XPATH,
'//button[contains(@class,"login-btn")]')
def login(self, email, password):
self.email_input.send_keys(email)
self.password_input.send_keys(password)
self.submit_button.click()
PageObject 模式要求每个项目维护一整套页面对象类。当项目有50个页面时，这套PageObject可能是几千行代码，任何一个页面的DOM变化，都可能导致10个测试用例需要更新。
问题三：数据准备和断言是手工活
传统测试框架中，数据准备（setup）和断言（assertion）都需要测试工程师手工编写。这部分工作占据了测试工程师60%以上的时间。
# 数据准备占用的精力往往是测试本身的好几倍
@pytest.fixture
def test_user_with_premium_subscription(self):
"""这个fixture可能是300行数据库设置代码"""
# 1. 创建测试用户
user = User.create(email="premium_test@example.com",
plan="premium")
# 2. 创建关联的订阅记录
subscription = Subscription.create(user_id=user.id,
plan="annual",
status="active")
# 3. 创建历史订单
orders = [Order.create(user_id=user.id) for _ in range(5)]
# 4. 设置测试数据到Redis缓存
redis_client.set(f"user:{user.id}:tier", "premium")
# 5. Mock外部API调用
mock_external_api.return_value({"tier": "premium"})
yield user
# 清理：又是一堆代码
user.delete()
Subscription.delete(subscription.id)
...
这个fixture的编写和维护成本，可能比被测试的业务逻辑本身还要高。而这恰恰是 AI 最擅长的领域——根据上下文自动推断需要哪些数据。
问题四：跨浏览器/跨平台测试的矩阵爆炸
Responsive design时代，移动端、平板、桌面端，加上不同的浏览器（Chrome、Firefox、Safari），测试矩阵可能达到20-30种组合。传统的并行化测试（parallel test）方案（如Selenium Grid）在资源消耗和维护成本上都很高。
1.2 AI时代的测试困境
有意思的是，AI编程助手（GitHub Copilot、Cursor、Claude Code）已经能帮工程师写业务代码了，但在测试环节，AI的介入程度依然很浅。大多数AI助手能做到的是：根据已有的函数签名，生成测试用例。但这要求测试工程师已经完成了最难的部分——设计测试策略、准备数据、构建场景。
真正的痛点是：测试设计本身，而不是测试编码。
Agent-fox 正是瞄准了这个根本问题：它让 AI 参与测试的设计环节，而不仅仅是编码环节。
二、Agent-fox 核心架构：从自然语言到测试执行的完整链路
2.1 整体架构概览
Agent-fox 的架构设计体现了 "AI Agent First" 的理念——整个测试执行过程由一个大型语言模型（LLM）驱动的 Agent 主导，而不是传统的预设脚本流程。
┌─────────────────────────────────────────────────────────────┐
│ Agent-fox 执行架构 │
│ │
│ ┌──────────────┐ │
│ │ 用户自然语言 │ "测试用户登录流程，包括错误的密码情况" │
│ │ 测试描述输入 │ │
│ └──────┬───────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────┐ │
│ │ LLM Agent（核心决策引擎） │ │
│ │ ┌───────────┐ ┌──────────┐ ┌────────────┐ │ │
│ │ │ 测试策略 │ │ 元素定位 │ │ 断言生成 │ │ │
│ │ │ 生成器 │ │ 智能引擎 │ │ │ │ │
│ │ └───────────┘ └──────────┘ └────────────┘ │ │
│ │ ┌───────────┐ ┌──────────┐ ┌────────────┐ │ │
│ │ │ 数据准备 │ │ 页面状态 │ │ 错误恢复 │ │ │
│ │ │ 协调器 │ │ 推理机 │ │ 策略器 │ │ │
│ │ └───────────┘ └──────────┘ └────────────┘ │ │
│ └──────────────────────┬────────────────────────┘ │
│ │ │
│ ┌──────────────┼──────────────┐ │
│ ▼ ▼ ▼ │
│ ┌───────────┐ ┌───────────┐ ┌───────────┐ │
│ │ Playwright │ │ 视觉回归 │ │ 报告生成 │ │
│ │ 执行器 │ │ 引擎 │ │ 器 │ │
│ └───────────┘ └───────────┘ └───────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
2.2 核心组件详解
组件一：自然语言解析引擎（NL Parser）
这是 Agent-fox 的入口模块，负责将用户的自然语言描述转换为结构化的测试意图（Test Intent）。
解析流程示例：
输入："测试一个付费用户登录后访问订阅管理页面，能看到历史订单列表，且订单金额正确显示为人民币"
NL Parser
│
▼
┌──────────────────────────────────────────────────────────┐
│ TestIntent { │
│ persona: "premium_user", // 角色：付费用户 │
│ primary_flow: "login", // 主流程：登录 │
│ navigation_target: "subscription", // 导航目标 │
│ data_verification: [ // 数据验证项 │
│ {field: "order_list", check: "visible"}, │
│ {field: "order_amount", check: "currency: CNY"} │
│ ], │
│ edge_cases: [ │
│ "wrong_password_rejection" │
│ ] │
│ } │
└──────────────────────────────────────────────────────────┘
NL Parser 的技术实现是一个微调过的 LLM，专门针对测试领域进行了指令微调（Instruction Tuning）。它不依赖通用的 GPT-4，而是使用了一个经过测试领域数据训练的模型，体积更小但对测试描述的理解准确率更高。
为什么不用通用GPT？
Agent-fox 团队在技术博客中解释了两个原因：
- 成本：通用 GPT-4 API 的调用成本是微调模型的20-30倍
- 准确性：测试描述有其特定的语言模式（如"验证...显示正确"、"测试...异常处理"），微调模型对这些模式的识别准确率比通用模型高约35%
组件二：智能元素定位引擎（Smart Locator）
传统测试框架中，元素定位是最脆弱的环节。Agent-fox 的 Smart Locator 用多策略融合的方式，大幅提升了元素定位的鲁棒性。
策略一：语义定位（Semantic Locating）
不再依赖XPath，而是根据元素的语义特征来定位：
# 传统方式（脆弱）
driver.find_element(By.XPATH, '//*[@id="login-form"]/div[2]/input')
# Agent-fox语义定位（鲁棒）
locator = SmartLocator.语义定位(
container="登录表单",
role="输入框",
label="邮箱地址",
type="email"
)
Smart Locator 内部会构建一个页面语义图（Page Semantic Graph），将页面的DOM结构转换为语义节点图：
class PageSemanticGraph:
"""
将DOM树转换为语义图，用于智能元素定位
"""
def __init__(self, page):
self.nodes = {}
self.edges = {}
def build_graph(self, dom_tree):
"""
遍历DOM树，构建语义节点
每个节点包含：
- role: aria-role 或隐式角色
- label: 关联的label文本
- text: 可见文本内容
- bbox: 视觉边界框
- semantic_score: 语义匹配得分
"""
for element in dom_tree.traverse():
node = SemanticNode(
id=element.id,
role=element.get_role(),
label=element.get_associated_label(),
text=element.get_visible_text(),
bbox=element.get_layout_bbox(),
semantic_score=0.0
)
self.nodes[element.id] = node
def match(self, intent: str) -> List[SemanticNode]:
"""
根据语义意图匹配元素
intent: "邮箱输入框"
返回匹配度最高的元素列表
"""
scored = []
for node in self.nodes.values():
score = self._calculate_match_score(node, intent)
if score > 0.6:
scored.append((node, score))
return [n for n, s in sorted(scored, key=lambda x: -x[1])]
def _calculate_match_score(self, node, intent) -> float:
"""综合打分：role匹配 + label匹配 + 视觉位置 + 上下文"""
score = 0.0
# role匹配（最重要）
if node.role in ["textbox", "input"]:
score += 0.4
if node.type == "email":
score += 0.3
# label文本匹配
if node.label and intent in node.label:
score += 0.2
# 上下文推理（如果附近有"邮箱"相关文本）
context = node.get_context_text()
if any(kw in context for kw in ["邮箱", "email", "Email"]):
score += 0.1
return min(score, 1.0)
策略二：视觉定位（Visual Locating）
当语义定位不够精确时，Smart Locator 会调用视觉模型进行辅助：
# 利用多模态模型识别元素位置
visual_box = VisualModel.locate(
screenshot=page.screenshot(),
intent="邮箱输入框",
model="clip"
)
这个策略的核心是视觉-语义对齐——同一个输入框，在PC端和移动端的DOM结构可能完全不同，但在视觉上的位置和外观是相似的。视觉定位利用这一特性，跨越不同设备形态进行精确定位。
策略三：自适应回退（Adaptive Fallback）
当主要定位策略失败时，Agent-fox 不会立即失败，而是自动尝试备选策略：
class AdaptiveFallback:
"""自适应回退机制"""
def __init__(self, primary_strategy):
self.strategies = [
primary_strategy, # 语义定位
VisualLocatingStrategy(), # 视觉定位
RelativeLocatingStrategy(), # 相对定位（基于邻居元素）
AccessibilityLocatingStrategy() # 无障碍属性定位
]
def locate(self, intent, page, max_attempts=3):
for i, strategy in enumerate(self.strategies):
try:
result = strategy.locate(intent, page)
if result.confidence > 0.7:
return result
except LocatorNotFound:
continue
# 所有策略都失败，触发Agent介入
return self._agent_directed_recovery(intent, page)
def _agent_directed_recovery(self, intent, page):
"""
当自动化策略都失败时，调用Agent进行智能恢复
Agent会分析页面状态，决定最合理的动作
"""
agent = LLMRetryAgent()
action = agent.decide_recovery_action(
intent=intent,
page_snapshot=page.get_snapshot(),
failure_history=self.failure_history
)
return action.execute()
这套三级回退机制是 Agent-fox 区别于传统测试框架的关键创新。传统框架在选择器失效时会直接失败，而 Agent-fox 会自动尝试多层备选方案，只有当所有方案都失败时才会触发人工介入。
组件三：数据准备智能体（Data Preparation Agent）
这是 Agent-fox 最有价值的功能之一——AI 自动推断并准备测试所需的数据。
工作原理：
# 用户只需要描述测试场景，数据由AI自动准备
result = agentfox.test(
scenario="测试一个付费用户登录后查看订阅详情",
model="gpt-4"
)
# Agent-fox 内部发生的事情：
# Step 1: 推断所需数据
# - 需要一个"付费用户"账号
# - 需要对应的订阅记录
# - 需要历史订单数据
#
# Step 2: 检查测试环境数据状态
# - 查询测试数据库中是否已有符合条件的用户
# - 如果没有，自动调用 signup API 创建
# - 如果已有，直接复用
#
# Step 3: 设置测试上下文
# - 注入 session cookie 或认证 token
# - 模拟订阅状态
# - 注入订单数据到 Redis 缓存
#
# Step 4: 执行测试
# - 复用准备好的测试数据
这个数据准备过程，传统的 PageObject 模式需要手工编写 100-300 行 fixture 代码，而在 Agent-fox 中只需要一句话描述。
数据准备的安全隔离：
Agent-fox 的数据准备采用了**影子数据（Shadow Data）**技术——测试数据在独立的数据库副本上操作，不影响生产数据：
class ShadowDataManager:
"""
影子数据管理：确保测试数据与生产数据隔离
"""
def __init__(self, production_db):
self.prod_db = production_db
# 创建影子数据库（只读快照）
self.shadow_db = self._create_shadow_snapshot()
def _create_shadow_snapshot(self):
"""从生产数据创建测试用快照"""
snapshot_id = f"test_shadow_{datetime.now().strftime('%Y%m%d%H%M%S')}"
# 实际实现中，这通常是一个数据库副本或只读视图
return DatabaseSnapshot(snapshot_id)
def get_or_create_user(self, persona: str):
"""根据角色获取或创建测试用户"""
if persona == "premium_user":
# 查询影子数据库
user = self.shadow_db.query(
"SELECT * FROM users WHERE plan='premium' LIMIT 1"
)
if not user:
# 创建新用户（写入测试数据库）
user = self._create_test_user({"plan": "premium"})
return user
# ... 其他角色同理
2.3 错误恢复与自愈机制
这是 Agent-fox 最引人注目的特性——测试脚本能够自动从错误中恢复，而不需要人工干预。
场景演示：
传统测试框架中，如果一个测试在执行过程中遇到意外状态（比如弹出了一个广告弹窗），测试就会失败：
# 传统框架遇到弹窗时的典型表现
def test_checkout(self):
# ... 执行到购物车结算
self.click_checkout_button()
# 突然弹出广告弹窗，打乱了流程
# 传统框架：直接失败 ❌
# Agent-fox：自动检测并处理 ✅
self.assert_text_present("Order Confirmed") # 永远执行不到这行
Agent-fox 的 Agent 模块会实时监控页面状态，并在发现异常时做出智能决策：
class PageStateMonitor:
"""页面状态实时监控"""
def __init__(self, agent: LLMAgent):
self.agent = agent
self.state_history = []
def on_step_complete(self, step: TestStep, page_state: PageSnapshot):
"""
每个测试步骤完成后调用
检测是否出现了意外状态
"""
unexpected = self._detect_unexpected_state(page_state)
if unexpected:
# 触发Agent决策：如何处理这个意外状态
action = self.agent.decide_recovery_action(
context=self._build_context(page_state),
unexpected_states=unexpected
)
action.execute()
def _detect_unexpected_state(self, page_state) -> List[UnexpectedState]:
"""检测意外状态"""
issues = []
# 检测弹窗
popups = page_state.detect_popups()
if popups:
issues.append(ModalPopup(popups))
# 检测加载失败
if page_state.has_network_errors():
issues.append(NetworkError(page_state.get_errors()))
# 检测页面内容异常
if page_state.has_layout_shifts():
issues.append(LayoutShift())
return issues
class RecoveryDecisionAgent:
"""
恢复决策Agent——根据上下文决定最佳动作
"""
def __init__(self, llm):
self.llm = llm
self.recovery_policies = {
"ModalPopup": self._handle_popup,
"NetworkError": self._handle_network_error,
"LayoutShift": self._handle_layout_shift
}
def decide_recovery_action(self, context, unexpected_states):
prompt = f"""
测试在执行过程中遇到了以下意外状态：
{unexpected_states}
当前页面URL: {context.current_url}
当前测试步骤: {context.current_step}
测试目标: {context.test_goal}
请决定最佳的处理动作。选项包括：
1. 关闭弹窗（如果是广告或cookie提示）
2. 等待页面重新加载
3. 重新导航到目标页面
4. 跳过当前步骤（如果非关键）
5. 标记测试为失败（如果异常不可恢复）
请以JSON格式返回：{{"action": "close_popup"|"reload"|"navigate"|"skip"|"fail", "params": {{}}}}。
"""
response = self.llm.complete(prompt)
return self._parse_and_execute(response)
三、实战：Agent-fox 完整使用流程
3.1 安装与配置
# 安装 agentfox
pip install agentfox
# 或使用 uv（更快）
uv add agentfox
# 初始化配置
agentfox init
# 配置LLM后端（支持多种模型）
agentfox config set llm.provider openai # or anthropic / local
agentfox config set llm.api_key sk-xxxx
agentfox config set llm.model gpt-4o # 默认模型
# 可选：配置浏览器（支持 Playwright 的所有浏览器）
agentfox config set browser chromium # chromium / firefox / webkit
agentfox config set headless true # 无头模式
3.2 第一个测试：用自然语言描述测试
from agentfox import AgentFox
af = AgentFox(base_url="https://your-app.com")
# 用自然语言描述测试场景
result = af.test("""
测试用户注册流程，包括以下场景：
1. 正常注册一个新用户，邮箱格式验证
2. 邮箱已存在时的错误提示
3. 密码强度不足时的提示
4. 注册成功后自动登录并跳转到欢迎页
""")
# 运行并获取报告
result.run()
print(result.summary)
Agent-fox 会自动：
- 解析测试意图
- 准备测试数据（随机生成测试邮箱等）
- 依次执行所有测试场景
- 每个失败场景自动尝试恢复
- 生成详细报告
3.3 报告输出示例
Agent-fox 的测试报告是其亮点之一——不仅包含传统的测试结果，还包含测试决策的可解释性报告，让你能看到AI为什么做了这个决策：
{
"test_id": "register_flow_20260517",
"status": "completed_with_warnings",
"total_steps": 12,
"passed": 11,
"failed": 0,
"warnings": 1,
"scenarios": [
{
"name": "正常注册新用户",
"status": "passed",
"steps": [
{"action": "navigate_to_register", "locator_used": "semantic", "success": true},
{"action": "fill_email", "locator_used": "semantic|email", "element": "#email-input", "success": true},
{"action": "fill_password", "locator_used": "visual_fallback", "element": "div:nth-child(2) input", "success": true},
{"action": "click_submit", "locator_used": "accessibility", "success": true}
]
},
{
"name": "邮箱已存在的错误提示",
"status": "passed",
"agent_decision": "detected 'email already exists' message matched expected error text"
},
{
"name": "密码强度不足",
"status": "passed",
"recovery_used": {
"type": "adaptive_fallback",
"attempts": 2,
"final_locator": "relative|near_label:密码"
}
}
],
"ai_decision_log": [
{
"timestamp": "12:34:05",
"event": "popup_detected",
"context": "ad modal appeared after submit click",
"agent_reasoning": "ad popup is a common pattern on this site, likely not related to test failure",
"action": "close_popup",
"success": true
},
{
"timestamp": "12:34:12",
"event": "element_not_found",
"context": "password strength indicator not found at expected location",
"agent_reasoning": "the strength indicator may have moved to a different location in the updated UI design",
"action": "adaptive_fallback",
"fallback_strategy": "visual|near_label:密码强度",
"success": true
}
]
}
四、性能对比：Agent-fox vs 传统测试框架
这是所有人最关心的问题——Agent-fox 真的比传统框架快吗？
4.1 稳定性对比
传统测试框架最大的痛点是 flaky test（不稳定测试）——同一个测试在相同环境下可能时而通过时而失败。Agent-fox 的自适应恢复机制，大幅降低了 flaky test 的比例：
| 指标 | Selenium | Playwright | Agent-fox |
|---|---|---|---|
| Flaky test 比例 | 15-25% | 5-10% | 1-3% |
| 元素定位成功率（页面改版后） | ~40% | ~55% | ~90% |
| 平均修复时间（MTTR） | 45min | 30min | 5min |
| 测试覆盖增长率/周 | 慢（工程师手工编写） | 慢 | 快（AI辅助生成） |
4.2 开发效率对比
| 指标 | Selenium | Playwright | Agent-fox |
|---|---|---|---|
| 编写一个端到端测试 | 45-90min | 30-60min | 5-10min（描述） |
| 维护成本（/月） | 高（选择器失效） | 中 | 低（自适应恢复） |
| 数据准备时间 | 30-60min | 20-40min | ~0（自动推断） |
| 新人上手时间 | 1-2周 | 3-5天 | 1-2天 |
4.3 执行效率
在执行速度上，Agent-fox 并没有比 Playwright 快——它的执行层底层调用的正是 Playwright。Agent-fox 的优势在于开发效率和鲁棒性，而不是执行速度。
对于 CI/CD 流水线来说，这意味着：
- 测试脚本的编写和维护时间大幅缩短
- 测试的稳定性提升，CI 的可靠性随之提升
- 覆盖率增长速度加快
五、局限性与适用场景
5.1 Agent-fox 的局限性
局限性一：依赖LLM的推理能力
Agent-fox 的核心能力完全依赖于底层 LLM 的推理质量。如果 LLM 的推理出现偏差（比如误解了测试意图），测试可能会执行错误的路径。
局限性二：API测试支持较弱
目前 Agent-fox 的主要使用场景是 UI 自动化测试。对于纯 API 测试场景（REST、GraphQL），它的支持还比较初级——更像是 LLM 生成测试代码，而不是端到端驱动。
局限性三：复杂业务场景的理解局限
当测试场景涉及复杂业务规则时，AI 可能会误解规则的优先级，导致测试覆盖不足：
# AI 可能无法理解的复杂业务规则
scenario = """
测试一个订阅折扣计算逻辑：
- 新用户首年5折
- 续费用户老带新优惠不可叠加
- 企业账号有单独的折扣体系
- 促销码与会员折扣互斥
- 黑五期间额外9折
- 上述所有规则按特定优先级计算
"""
# AI 可能只覆盖了前2-3条规则，遗漏了边界情况
局限性四：调试成本
当 Agent-fox 执行了错误路径时，定位问题原因可能比传统测试更困难——因为问题可能出在 LLM 的推理层，而不是代码层。
5.2 最佳适用场景
场景一：快速迭代的中小型产品
对于每周发布2-3个小版本的产品，传统的 XPath 维护成本会非常高。Agent-fox 的自适应定位可以显著减少因页面改版导致的测试维护工作。
场景二：测试资源有限的小团队
只有1-2个QA工程师的小团队，可以用 Agent-fox 快速扩展测试覆盖范围，而不需要雇佣更多测试工程师。
场景三：验收测试（UAT）阶段
在用户验收测试阶段，用自然语言描述测试场景比编写代码更符合业务人员的思维方式。
5.3 不适用场景
- 超大规模回归测试（5000+用例）：Agent-fox 的AI推理成本在高并发测试场景下会非常高
- 严格的性能测试：执行速度不如传统框架
- 需要精确定位控制的场景：如游戏自动化、复杂Canvas操作
六、技术原理：深入 Agent-fox 的 Agent 实现
6.1 Agent 的决策循环
Agent-fox 的核心是一个 ReAct（Reasoning + Acting）循环，每一步测试执行都遵循"推理→决策→执行→反馈"的循环：
class AgentFoxAgent:
"""
Agent-fox 的核心Agent实现
采用 ReAct (Reasoning + Acting) 模式
"""
def __init__(self, llm, executor):
self.llm = llm
self.executor = executor
self.max_iterations = 50
self.execution_history = []
def run_test_scenario(self, scenario: TestIntent) -> TestResult:
state = ExecutionState(scenario)
iteration = 0
while not state.is_terminal() and iteration < self.max_iterations:
iteration += 1
# Step 1: 推理——分析当前状态，决定下一步
reasoning = self.llm.reason(
prompt=self._build_reasoning_prompt(state)
)
state.add_reasoning(reasoning)
# Step 2: 决策——从推理结果中提取动作
action = self._extract_action(reasoning)
# Step 3: 执行——在浏览器或API层执行动作
result = self.executor.execute(action, state.page)
# Step 4: 反馈——观察执行结果，更新状态
observation = Observation(
action=action,
result=result,
page_snapshot=state.page.snapshot()
)
state.add_observation(observation)
# Step 5: 评估——判断是否达成目标
if state.check_success_criteria():
state.mark_success()
elif state.check_irrecoverable_failure():
state.mark_failure(reason="Irrecoverable")
return state.to_result()
def _build_reasoning_prompt(self, state: ExecutionState) -> str:
"""构建推理提示词"""
return f"""
当前测试场景：{state.scenario.description}
测试目标：{state.scenario.goal}
已执行步骤：
{self._format_history(state.execution_history)}
当前页面状态：
URL: {state.page.url}
标题: {state.page.title}
主要元素: {state.page.get_main_elements()}
请决定下一步动作：
- 要执行什么操作？（click / fill / navigate / assert / wait...）
- 操作目标是什么？（哪个元素，要做什么内容）
- 你的推理依据是什么？
"""
def _extract_action(self, reasoning: str) -> TestAction:
"""从LLM推理结果中提取结构化动作"""
# 使用 LLM 的 function calling 能力提取结构化动作
extraction_prompt = f"""
从以下推理中提取结构化的测试动作：
{reasoning}
请输出JSON格式的动作定义：
{{
"type": "click|fill|navigate|assert|wait|javascript",
"target": "元素定位描述",
"value": "填充内容（如果适用）",
"assertion": "断言内容（如果适用）",
"reasoning": "选择这个动作的原因"
}}
"""
response = self.llm.complete(extraction_prompt, format="json")
return TestAction.from_json(response)
6.2 长期记忆与学习
Agent-fox 还支持长期记忆——同一个项目的测试历史会被保存下来，Agent 会从历史失败中学习：
class TestMemory:
"""
测试记忆：记录历史测试行为，用于Agent学习
"""
def __init__(self, db_path=".agentfox/memory.db"):
self.db = sqlite3.connect(db_path)
self._init_schema()
def record_execution(self, test_id, actions, outcomes, learnings):
"""
记录测试执行历史，供后续Agent学习
"""
cursor = self.db.cursor()
cursor.execute("""
INSERT INTO test_history (test_id, actions, outcomes, learnings, timestamp)
VALUES (?, ?, ?, ?, ?)
""", (test_id, json.dumps(actions), json.dumps(outcomes),
json.dumps(learnings), datetime.now().isoformat()))
self.db.commit()
def get_learnings(self, context_keywords: List[str]) -> List[str]:
"""
根据当前测试上下文，获取相关的历史学习经验
"""
cursor = self.db.cursor()
# 查找相关的历史成功经验
cursor.execute("""
SELECT learnings FROM test_history
WHERE outcomes LIKE '%success%'
AND (""" + " OR ".join(["learnings LIKE ?" for _ in context_keywords]) + """)
ORDER BY timestamp DESC
LIMIT 5
""", [f"%{kw}%" for kw in context_keywords])
return [row[0] for row in cursor.fetchall()]
这个记忆系统让 Agent-fox 能够随时间积累对被测系统的理解——越用越"懂"这个系统。
七、未来展望：AI 测试的下一阶段
7.1 当前行业趋势
Agent-fox 的出现，是 2026 年 AI + Testing 融合趋势的一个缩影。类似的项目还包括：
- CodiumAI（现在叫 PrimeLogic）：用 AI 生成单元测试，已获 5000 万美元融资
- Diffblue：基于 AI 的测试生成，被 SAP 收购
- Microsoft Playwright Labs：在 Playwright 中集成 AI 辅助定位
- Testagent.io：多Agent协作的端到端测试平台
7.2 Agent-fox 的路线图
根据项目 README 的披露，Agent-fox 未来的发展方向包括：
- 多模态测试理解：利用视觉模型分析页面截图，生成更鲁棒的测试
- 视频流测试支持：针对 WebRTC、视频播放等场景的特殊支持
- 团队协作模式：企业版支持多人共享测试记忆和 PageObject 库
- 性能测试集成：在 UI 测试过程中自动采集性能数据
- 跨平台支持：除 Web 外，扩展到移动原生（iOS/Android）和桌面应用
7.3 对 QA 工程师的影响
这是很多人关心的问题：AI 测试框架会取代 QA 工程师吗？
结论：不会取代，但会重新定义角色。
Agent-fox 解决的是重复性测试工作的问题——元素的维护、数据的准备、不稳定因素的修复。但测试策略的设计、业务风险的识别、边界的探索，依然需要经验丰富的 QA 工程师来主导。
更准确地说，Agent-fox 这样的工具，是把 QA 工程师从"测试编码者"提升为"测试策略师"。QA 工程师的产出从"每天20个测试用例"变成"每天设计200个测试场景（由AI执行）"。这个变化是巨大的，但它需要 QA 工程师去适应新的工作模式——学习如何用自然语言准确描述测试意图，理解 Agent 的能力边界，并在必要时进行人工干预和校正。
八、总结：测试的下一个十年
回顾自动化测试的发展历程，我们可以清晰地看到三条主线的演进：
第一条线：工具进化
Selenium（2004）→ WebDriver 协议标准化（2011）→ Playwright（2020）→ Agent-fox（2026）
这条线解决的是"如何控制浏览器"的问题，从原始的 JavaScript 注入，到协议标准化，再到多浏览器原生支持。
第二条线：测试编写方式
手工编码 → PageObject 封装 → BDD 描述 → AI 自然语言
这条线解决的是"谁来编写测试"的问题，从开发者编写，到业务人员参与描述，再到 AI 自动生成。
第三条线：维护方式
硬编码选择器 → PageObject 集中维护 → AI 自适应定位 → AI 自动恢复
这条线解决的是"如何减少维护成本"的问题，从改进代码结构，到 AI 自动修复。
Agent-fox 的意义是什么？
它不是一个更快的 Selenium，而是一次测试理念的升级。它把测试从"编程活动"重新定义为"描述活动"——你描述你想要验证的行为，AI 负责实现这个验证。这意味着测试的门槛大幅降低，更多的人可以参与测试设计；同时测试的效率大幅提升，同一个人可以做更多的测试。
对于测试工程师来说，这是一个警醒也是一个机会：如果你还在用 XPath 编写测试，现在正是转型的时候。 未来的测试工程师需要的核心技能，不是掌握多少种选择器API，而是理解业务逻辑、设计测试策略、以及与 AI Agent 协作的能力。
测试的下一个十年，属于那些能够驾驭 AI 的人。