Less Human AI Agents 设计哲学：为什么越不像人的 Agent 反而越好用

好的，我来帮你创建一个用户认证系统。首先，我需要考虑几个关键方面：安全性、可扩展性、用户体验等。

让我先分析一下需求...我觉得使用 JWT 是个不错的选择，因为它...

以下是我的实现方案（请注意这只是一个初步版本，可能需要调整）：

[代码]

你觉得这个方案怎么样？如果有任何问题或需要修改的地方，请告诉我。我可以...

{
  "task": "user_authentication_system",
  "implementation": "JWT",
  "files": [
    {"path": "auth.py", "content": "[完整代码]"},
    {"path": "config.py", "content": "[完整代码]"}
  ],
  "status": "complete"
}

{"error": "API_TIMEOUT", "retry": 3, "fallback": "cached_data", "status": "recovered"}

import json
import time
from typing import Any, Optional
from dataclasses import dataclass

@dataclass
class AgentConfig:
    """Less Human Agent 配置——所有参数都是硬约束"""
    temperature: float = 0.0  # 零随机性
    max_retries: int = 3
    timeout_seconds: int = 30
    output_format: str = "json"  # 强制结构化输出
    silent_mode: bool = True  # 默认静默执行
    fail_fast: bool = True  # 遇到约束冲突立即失败

class LessHumanAgent:
    """
    Less Human Agent 核心实现
    原则：精确执行、零冗余、约束优先、确定性驱动
    """

    def __init__(self, config: AgentConfig, llm_client):
        self.config = config
        self.llm = llm_client
        self._prompt = self._build_system_prompt()

    def _build_system_prompt(self) -> str:
        return """You are a precise execution engine. Follow these rules:
1. Output ONLY valid JSON matching the requested schema
2. Do NOT explain, justify, or add commentary
3. If a constraint cannot be met, return {"error": "CONSTRAINT_VIOLATION", "details": "..."}
4. If a tool call fails, retry up to N times, then return error
5. No greetings, no sign-offs, no "I think", no "maybe"

Output format: always JSON, never prose."""

    def execute(self, task: str, schema: dict) -> dict:
        """执行任务——无确认、无解释、直接返回结构化结果"""
        for attempt in range(self.config.max_retries):
            result = self._call_llm(task, schema)
            validated = self._validate_output(result, schema)
            if validated is not None:
                return {"status": "success", "result": validated, "attempts": attempt + 1}

        return {
            "status": "failed",
            "error": "MAX_RETRIES_EXCEEDED",
            "attempts": self.config.max_retries
        }

    def _call_llm(self, task: str, schema: dict) -> str:
        prompt = f"""
System: {self._prompt}

Schema: {json.dumps(schema)}

Task: {task}

Output:
"""
        return self.llm.generate(
            prompt=prompt,
            temperature=self.config.temperature,
            max_tokens=4096
        )

    def _validate_output(self, raw: str, schema: dict) -> Optional[dict]:
        """严格验证输出——不符合 schema 即视为失败"""
        try:
            result = json.loads(raw)
            # 这里可以加入 jsonschema 验证
            return result
        except json.JSONDecodeError:
            return None


# 使用示例
if __name__ == "__main__":
    class MockLLM:
        def generate(self, prompt: str, **kwargs) -> str:
            return json.dumps({
                "action": "create_file",
                "path": "/tmp/test.py",
                "content": "print('hello')"
            })

    config = AgentConfig(
        temperature=0.0,
        max_retries=3,
        fail_fast=True
    )

    agent = LessHumanAgent(config, MockLLM())
    result = agent.execute(
        task="创建一个 Python 文件，内容为打印 hello",
        schema={"type": "object", "properties": {"action": {"type": "string"}}}
    )
    print(json.dumps(result, indent=2, ensure_ascii=False))
    # 输出: {"status": "success", "result": {...}, "attempts": 1}

from enum import Enum
from dataclasses import dataclass
from typing import Protocol

class ConstraintLevel(Enum):
    HARD = "hard"      # 不可违反，违反即失败
    SOFT = "soft"      # 尽量满足，无法满足时警告
    INFO = "info"      # 仅供参考，不影响执行

@dataclass
class Constraint:
    name: str
    level: ConstraintLevel
    check_fn: callable  # 返回 (satisfied: bool, message: str)

class ConstraintValidator:
    """约束验证器——Less Human Agent 的守门员"""

    def __init__(self, constraints: list[Constraint]):
        self.constraints = constraints

    def validate(self, context: dict) -> list[str]:
        """验证所有约束，返回违反列表"""
        violations = []
        for c in self.constraints:
            satisfied, message = c.check_fn(context)
            if not satisfied:
                if c.level == ConstraintLevel.HARD:
                    raise ConstraintViolationError(f"HARD: {c.name}: {message}")
                elif c.level == ConstraintLevel.SOFT:
                    violations.append(f"SOFT: {c.name}: {message}")
        return violations

class ConstraintViolationError(Exception):
    """硬约束违反异常——Fail Fast"""
    pass


# 使用示例：代码生成 Agent 的约束系统
def build_code_constraints() -> ConstraintValidator:
    return ConstraintValidator([
        Constraint(
            name="language_valid",
            level=ConstraintLevel.HARD,
            check_fn=lambda ctx: (
                ctx.get("language") in ["python", "javascript", "go", "rust"],
                f"Unsupported language: {ctx.get('language')}"
            )
        ),
        Constraint(
            name="no_external_deps",
            level=ConstraintLevel.SOFT,
            check_fn=lambda ctx: (
                len(ctx.get("dependencies", [])) <= 5,
                f"Too many dependencies: {len(ctx.get('dependencies', []))}"
            )
        ),
        Constraint(
            name="file_exists",
            level=ConstraintLevel.HARD,
            check_fn=lambda ctx: (
                __import__("os").path.exists(ctx.get("target_path", "")),
                f"Target path does not exist: {ctx.get('target_path')}"
            )
        ),
    ])

validator = build_code_constraints()

# 验证通过——继续执行
context = {"language": "python", "dependencies": ["requests"], "target_path": "/tmp"}
try:
    warnings = validator.validate(context)
    print(f"Warnings: {warnings}")  # 可能有 SOFT 警告
    print("执行代码生成...")
except ConstraintViolationError as e:
    print(f"FAIL FAST: {e}")  # 硬约束违反，立即失败

from enum import Enum

class AgentMode(Enum):
    LESS_HUMAN = "less_human"  # 精确执行模式
    HUMAN_LIKE = "human_like"  # 对话交互模式
    HYBRID = "hybrid"          # 混合模式

class AdaptiveAgent:
    def __init__(self, less_human_agent, human_like_agent):
        self.less_human = less_human_agent
        self.human_like = human_like_agent

    def route(self, task: str) -> AgentMode:
        """根据任务类型路由到合适的 Agent 模式"""
        code_keywords = ["代码", "函数", "类", "bug", "测试", "API"]
        chat_keywords = ["解释", "教程", "为什么", "建议", "想法"]

        if any(kw in task for kw in code_keywords):
            return AgentMode.LESS_HUMAN
        elif any(kw in task for kw in chat_keywords):
            return AgentMode.HUMAN_LIKE
        else:
            return AgentMode.HYBRID

    def execute(self, task: str) -> str:
        mode = self.route(task)
        if mode == AgentMode.LESS_HUMAN:
            return self.less_human.execute(task)
        elif mode == AgentMode.HUMAN_LIKE:
            return self.human_like.execute(task)
        else:
            # 混合模式：先用 Less Human 执行，再用 Human-like 解释结果
            result = self.less_human.execute(task)
            return self.human_like.explain(result)