Коли ваші інструменти відстежують себе, еволюціонують самих себе, і обирають самих себе.
Примітка: Це частина 8 у серії семантичних розвідувальних питань. Частина 7 охоплює загальну архітектуру DSE. Ця стаття занурюється глибоко в те, що я оприлюднив: те, як самі інструменти працюють, використовують їх, еволюціонують і стають розумнішими з часом.
Примітка: Якщо ви вважаєте, що робота над еволюцією в 7-ій частині була дикою, почекайте, поки ви побачите, що станеться, кожен інструмент має однакові можливості.
У 7-ій частині я показав вам директивну Синтетичну еволюцію: роботу, що планує, виробляє, виконує, оцінює та покращує.
Ось що я не пояснив:
Эти инструменты? которые там не изменились.
Вони є живими артефактами:
Іншими словами: Інструменти - це вузли. Вузли - це інструменти. Все розвивається.
И становится странно.
Дозвольте мені показати вам, що ця система має насправді:
$ ls -la tools/
drwxr-xr-x llm/ # LLM-based tools (27 specialists)
drwxr-xr-x executable/ # Executable validators/generators
drwxr-xr-x openapi/ # External API integrations
drwxr-xr-x custom/ # User-defined tools
-rw-r--r-- index.json # 5,464 lines of tool metadata
Ось. index.json? 5 644 рядки визначення інструментів, використання статистики, історії версій, оцінки придатності та відстеження родоводу.
Будь- який інструмент там:
ЗАУВАЖЕННЯ: система запускатиметься без будь- яких інструментів. Просто менш ефективно і тупіше. Без цих інструментів буде створено звичайну частину компонування робочого процесу. Ця система буде повільно адаптуватися, але буде потрібна набагато більше елементів.
Давайте поглянемо, що таке інструмент насправді.
Ось справжнє визначення інструмента з системи:
tools/llm/long_form_writer.yaml
name: "Long-Form Content Writer"
type: "llm"
description: "Specialized for writing long-form content (novels, books, long articles) using mistral-nemo's massive 128K context window."
cost_tier: "high"
speed_tier: "slow"
quality_tier: "excellent"
max_output_length: "very-long"
llm:
model: "mistral-nemo"
endpoint: null
system_prompt: "You are a creative writer specializing in long-form content. You have a massive 128K token context window..."
prompt_template: "{prompt}\n\nPrevious context:\n{context}\n\nGenerate the next section maintaining consistency."
tags: ["creative-writing", "novel", "story", "long-form", "article", "book", "large-context"]
Зауважте, що там:
Але ось що. неDescription of a condition. Do not translate key words (# V1S #, # V1 #,) у YAML:
# Auto-generated at runtime:
tool.usage_count = 47 # How many times used
tool.version = "1.2.0" # Semantic versioning
tool.definition_hash = "a3f5..."# Change detection
tool.quality_score = 0.89 # From evaluations
tool.avg_latency_ms = 12_400 # Performance tracking
tool.last_updated = "2025-11-15"
Система Доповнення Статичні визначення під час навчання.
Ось що станеться, коли ви використовуєте інструмент:
# User request
result = tools_manager.invoke_llm_tool(
tool_id="long_form_writer",
prompt="Write a romance novel chapter"
)
# Behind the scenes:
sequenceDiagram
participant U as User
participant TM as ToolsManager
participant RAG as RAG Memory
participant LLM as Long Form Writer
participant Metrics as Metrics Tracker
U->>TM: invoke_llm_tool("long_form_writer", prompt)
TM->>RAG: Check cache (tool + prompt hash)
alt Cache Hit
RAG-->>TM: Cached response (v1.2.0, fitness: 0.89)
TM->>Metrics: Increment cache_hits
TM-->>U: Return cached result ✓
else Cache Miss
TM->>Metrics: Start timer
TM->>LLM: Generate response
LLM-->>TM: Response
TM->>Metrics: Record latency, quality
TM->>RAG: Store invocation with metadata
TM->>TM: Update tool.usage_count++
TM-->>U: Return result
end
TM->>Metrics: Update adaptive timeout stats
TM->>RAG: Update tool fitness score
За чим слідкують:
Давайте поглянемо на механізм кешування.
Наймудріше: інструмент кешування системи на декількох рівнях.
Рівень 1: Точний кеш збігів
def invoke_llm_tool(self, tool_id: str, prompt: str) -> str:
"""Invoke LLM tool with hierarchical caching."""
# Normalize prompt for exact matching
normalized_prompt = prompt.lower().strip()
# Search RAG for previous invocations
tool_invocations = self.rag_memory.find_by_tags(
["tool_invocation", tool_id],
limit=100
)
# Find ALL exact matches for this tool + prompt
matches = []
for artifact in tool_invocations:
cached_prompt = artifact.metadata.get("user_prompt", "").lower().strip()
if cached_prompt == normalized_prompt:
# Collect fitness and version
matches.append({
"artifact": artifact,
"fitness": artifact.metadata.get("fitness_score", 0.0),
"version": artifact.metadata.get("version", "1.0.0"),
"timestamp": artifact.metadata.get("timestamp", 0)
})
if matches:
# Select LATEST, HIGHEST FITNESS version
best_match = sorted(
matches,
key=lambda m: (m["fitness"], m["timestamp"]),
reverse=True
)[0]
logger.info(
f"✓ CACHE HIT: Reusing result for '{tool.name}' "
f"(version {best_match['version']}, fitness {best_match['fitness']:.2f})"
)
# Increment usage counters
self.increment_usage(tool_id)
self.rag_memory.increment_usage(artifact.artifact_id)
return best_match["artifact"].content
Чому це є важливим:
Якщо ви попросите систему "писати хайку про код" двічі, вдруге - миттєво. LLM не запущено. Пам' ять RAG повертає кешований результат.
Але ось ще один розумний момент: вона повертає версію BEST якщо існує декілька.
Приклад:
Invocation 1: "write a haiku about code"
→ Generated with tool v1.0.0
→ Fitness: 0.75
→ Stored in RAG
Invocation 2: "write a haiku about code" (exact match!)
→ Tool evolved to v1.1.0
→ Fitness: 0.92 (better!)
→ Stored in RAG
Invocation 3: "write a haiku about code"
→ Finds BOTH cached versions
→ Selects v1.1.0 (higher fitness + later timestamp)
→ Returns best result instantly
Система автоматично вибирає високоякісний результат.
Одна з найшумніших особливостей: система дізнається, скільки часу займає кожна модель, щоб відповісти на неї.
Проблема:
Різні моделі мають різний час реакції:
tinyllama (2Б): ~3 секундиllama3 (8Б): ~10 секундqwen2.5-coder (14B): ~25 секундdeepseek-coder-v2 (16B): ~60 секундЯкщо ви встановите глобальний час очікування (наприклад, 30), ви втрачаєте 27 секунд очікування на tinyllama, і ти вбиваєш deepseek до того, як вона закінчиться.
Розв'язання.
def _update_adaptive_timeout(
self,
model: str,
tool_id: str,
response_time: float,
timed_out: bool,
prompt_length: int
):
"""Learn optimal timeout from actual performance."""
# Get existing stats
stats_id = f"timeout_stats_{model.replace(':', '_')}"
existing = self.rag_memory.get_artifact(stats_id)
if existing:
response_times = existing.metadata.get("response_times", [])
timeout_count = existing.metadata.get("timeout_count", 0)
success_count = existing.metadata.get("success_count", 0)
else:
response_times = []
timeout_count = 0
success_count = 0
# Update stats
if timed_out:
timeout_count += 1
else:
success_count += 1
response_times.append(response_time)
response_times = response_times[-50:] # Keep last 50
# Calculate recommended timeout (95th percentile + 20% buffer)
if response_times:
sorted_times = sorted(response_times)
p95_index = int(len(sorted_times) * 0.95)
p95_time = sorted_times[min(p95_index, len(sorted_times) - 1)]
recommended_timeout = int(p95_time * 1.2)
logger.info(
f"Adaptive timeout for {model}: {recommended_timeout}s "
f"(based on {len(response_times)} samples)"
)
Як це працює:
Результати:
Model: tinyllama
Samples: 50
95th percentile: 3.2s
Recommended timeout: 4s (3.2 * 1.2)
Model: qwen2.5-coder:14b
Samples: 50
95th percentile: 28.5s
Recommended timeout: 34s (28.5 * 1.2)
Система отримує правильний час очікування для кожної моделі Замість глобального значення.
Якщо ви попросите систему щось зробити, вона не просто обирає перший інструмент для пошуку. функція фітнесу у різних вимірах.
Підрахунок відповідності:
def calculate_fitness(tool, similarity_score):
"""
Calculate overall fitness score (0-100+).
Factors:
- Semantic similarity (how well it matches the task)
- Speed (fast tools get bonus)
- Cost (cheap tools get bonus)
- Quality (high-quality tools get bonus)
- Historical success rate~~~~
- Latency metrics
- Reuse potential
"""
fitness = similarity_score * 100 # Base: 0-100
metadata = tool.metadata or {}
# Speed bonus/penalty
speed_tier = metadata.get('speed_tier', 'medium')
if speed_tier == 'very-fast':
fitness += 20
elif speed_tier == 'fast':
fitness += 10
elif speed_tier == 'slow':
fitness -= 10
elif speed_tier == 'very-slow':
fitness -= 20
# Cost bonus (cheaper = better for most tasks)
cost_tier = metadata.get('cost_tier', 'medium')
if cost_tier == 'free':
fitness += 15
elif cost_tier == 'low':
fitness += 10
elif cost_tier == 'high':
fitness -= 10
elif cost_tier == 'very-high':
fitness -= 15
# Quality bonus
quality_tier = metadata.get('quality_tier', 'good')
if quality_tier == 'excellent':
fitness += 15
elif quality_tier == 'very-good':
fitness += 10
elif quality_tier == 'poor':
fitness -= 15
# Success rate from history
quality_score = metadata.get('quality_score', 0)
if quality_score > 0:
fitness += quality_score * 10 # 0-10 bonus
# Latency metrics
latency_ms = metadata.get('latency_ms', 0)
if latency_ms > 0:
if latency_ms < 100:
fitness += 15 # Very fast
elif latency_ms < 500:
fitness += 10
elif latency_ms > 5000:
fitness -= 10 # Too slow
# Reuse bonus: existing workflow = less effort
if tool.tool_type == ToolType.WORKFLOW:
if similarity >= 0.90:
fitness += 30 # Exact match!
elif similarity >= 0.70:
fitness += 15 # Template reuse
return fitness
Справжній приклад:
Task: "Quickly validate this email address"
Tools found:
1. email_validator_workflow (similarity: 0.95)
- Speed: very-fast (+20)
- Cost: free (+15)
- Quality: excellent (+15)
- Latency: 45ms (+15)
- Reuse: exact match (+30)
→ FINAL FITNESS: 190
2. general_validator (similarity: 0.70)
- Speed: medium (+0)
- Cost: free (+15)
- Quality: good (+10)
- Latency: 850ms (+0)
- Reuse: none (+0)
→ FINAL FITNESS: 95
3. llm_based_validator (similarity: 0.65)
- Speed: slow (-10)
- Cost: high (-10)
- Quality: excellent (+15)
- Latency: 8200ms (-10)
- Reuse: none (+0)
→ FINAL FITNESS: 50
Вибрано: email_validator_workflow (зручність: 190)
Система вибирає швидкий, вільний, високоякісний, перевірений Решение, не самое семантичное, не самое могущественное.
Той, що оптимально задовольняє декілька обмежень.
Інструменти не залишаються статичними.
Виявлення і зміна версії:
Кожен інструмент має хеш визначення обчислений з його YAML:
def calculate_tool_hash(tool_def: Dict[str, Any]) -> str:
"""SHA256 hash of tool definition for change detection."""
stable_json = json.dumps(tool_def, sort_keys=True)
return hashlib.sha256(stable_json.encode('utf-8')).hexdigest()
Якщо ви редагуєте інструмент YML:
# BEFORE (v1.0.0)
name: "Email Validator"
tags: ["email", "validation"]
# AFTER (edit the YAML)
name: "Email Validator"
tags: ["email", "validation", "dns-check"] # Added DNS checking!
Під час наступного завантаження:
# System detects change
new_hash = calculate_tool_hash(tool_def) # Different!
old_hash = existing_tool.definition_hash
if old_hash != new_hash:
# Determine change type
change_type = tool_def.get("change_type", "patch") # minor, major, patch
# Bump version
old_version = "1.0.0"
new_version = bump_version(old_version, change_type)
# new_version = "1.1.0" (minor change)
console.print(
f"[yellow]↻ Updated email_validator "
f"v{old_version} → v{new_version} ({change_type})[/yellow]"
)
Семантична версія:
def bump_version(current_version: str, change_type: str) -> str:
"""Bump semver based on change type."""
major, minor, patch = map(int, current_version.split('.'))
if change_type == "major":
return f"{major + 1}.0.0" # Breaking changes
elif change_type == "minor":
return f"{major}.{minor + 1}.0" # New features
else: # patch
return f"{major}.{minor}.{patch + 1}" # Bug fixes
Breaking changes:
name: "Email Validator"
version: "2.0.0"
change_type: "major"
breaking_changes:
- "Changed return format from boolean to object"
- "Removed deprecated 'simple_check' parameter"
- "Now requires 'domain' to be specified"
Під час завантаження:
[yellow]↻ Updated email_validator v1.3.2 → v2.0.0 (major)[/yellow]
[red]! Breaking changes:[/red]
- Changed return format from boolean to object
- Removed deprecated 'simple_check' parameter
- Now requires 'domain' to be specified
Система попереджати вас про відмову від змін і підтримує історію версій.
Кожен інструмент індексується у пам' яті RAG для семантичного пошуку:
На час завантаження:
def _store_yaml_tool_in_rag(self, tool: Tool, tool_def: dict, yaml_path: str):
"""Store YAML tool in RAG for semantic search."""
# Build comprehensive content for embedding
content_parts = [
f"Tool: {tool.name}",
f"ID: {tool.tool_id}",
f"Type: {tool.tool_type.value}",
f"Description: {tool.description}",
f"Tags: {', '.join(tool.tags)}",
""
]
# Add input/output schemas
if tool_def.get("input_schema"):
content_parts.append("Input Parameters:")
for param, desc in tool_def["input_schema"].items():
content_parts.append(f" - {param}: {desc}")
# Add examples
if tool_def.get("examples"):
content_parts.append("Examples:")
for example in tool_def["examples"]:
content_parts.append(f" {example}")
# Add performance tiers
content_parts.append("Performance:")
content_parts.append(f" Cost: {tool_def['cost_tier']}")
content_parts.append(f" Speed: {tool_def['speed_tier']}")
content_parts.append(f" Quality: {tool_def['quality_tier']}")
# Add full YAML
import yaml
content_parts.append("Full Definition:")
content_parts.append(yaml.dump(tool_def))
tool_content = "\n".join(content_parts)
# Store in RAG with metadata
self.rag_memory.store_artifact(
artifact_id=f"tool_{tool.tool_id}",
artifact_type=ArtifactType.PATTERN,
name=tool.name,
description=tool.description,
content=tool_content,
tags=["tool", "yaml-defined", tool.tool_type.value] + tool.tags,
metadata={
"tool_id": tool.tool_id,
"tool_type": tool.tool_type.value,
"is_tool": True,
"version": tool_def.get("version", "1.0.0"),
"cost_tier": tool_def.get("cost_tier"),
"speed_tier": tool_def.get("speed_tier"),
"quality_tier": tool_def.get("quality_tier")
},
auto_embed=True # Generate embedding!
)
Тепер під час пошуку:
# Semantic tool search
results = tools_manager.search("email validation", top_k=5)
# Results (ranked by fitness, not just similarity):
[
Tool(id="email_validator", fitness=190, similarity=0.95),
Tool(id="domain_checker", fitness=140, similarity=0.82),
Tool(id="regex_validator", fitness=110, similarity=0.78),
Tool(id="general_validator", fitness=95, similarity=0.70),
Tool(id="string_validator", fitness=60, similarity=0.65)
]
Використання системи Вбудовування RAG знайти відповідні інструменти, а потім показати їх у вигляді Багатовимірна фізкультура.
У нашій системі ми зберігаємо вектори для вбудовування в Qdrant Векторна база даних, яка надає нам змогу спостерігати за нашим простором інструментів. Це система пам' яті нашої системи побудови робочого процесу.
Розділений на початкові шаблони (файли yaml у каталозі інструментів) і всі елементи коду, створені для розв' язання завдання (і налаштування для llms тощо). Ці форми призначено для набору робочих аркушів на інструментах. Попередньо вбудовані шматки належать до &;
Таким чином, всі робочі поля будуть композитивними і придатними для перевірки, оскільки кожен елемент Python має набір тестів, специфіка BDD, статичні інструменти для перевірки коректності та декількох вимірювачів LLM для забезпечення того, щоб вони працювали.
побічним ефектом є ВСІ елементи коду, які будуть виконуватися у робочому процесі, ось тут, готові до перевірки кожного створення " інструмента " призводить до перевірки на Python scrips.
Ви можете побачити, що торжество разом з кожною плямою є семантаічно пов'язаним набором інструментів на зразок:
Звичайно, це залежить від природи цієї системи.
У майбутньому ми, ймовірно, захочемо оптимізувати ці скупчення, щоб зменшити кодову базу до меншої, міцнішої, більш оптимізованої системи.
Як ми можемо стежити за версіями, використанням, змінами та брехнею, ми можемо вибірково оптимізовано та 'cluster defrag' tnhe найбільш використаних і найбільш критичних комуніціацій як частина структури системи.
Давайте поглянемо, що насправді існує в системі зараз.
Інструменти LLM (27 спеціалістів):
$ ls tools/llm/
article_analyzer.yaml # Analyzes articles for structure/quality
code_explainer.yaml # Explains code in natural language
code_optimizer.yaml # Hierarchical optimization (local/cloud/deep)
code_reviewer.yaml # Reviews code for quality/security
content_generator.yaml # General content generation
doc_generator.yaml # Generates documentation
fast_code_generator.yaml # Quick code generation (small models)
general.yaml # General-purpose fallback
long_form_writer.yaml # Novels, books (128K context!)
model_selector.yaml # Selects best backend/model
performance_profiler.yaml # Profiles code performance
quick_feedback.yaml # Fast triage/feedback
quick_translator.yaml # Fast translation
security_auditor.yaml # Security vulnerability scanning
signalr_connection_parser.yaml # Parses SignalR connections
signalr_llmapi_management.yaml # Manages SignalR LLM API
summarizer.yaml # Summarizes long content
task_to_workflow_router.yaml # Routes tasks to workflows
technical_writer.yaml # Technical documentation
translation_quality_checker.yaml # Validates translations
workflow_documenter.yaml # Auto-generates workflow docs
Інструменти виконання:
$ ls tools/executable/
call_tool_validator.yaml # Validates call_tool() usage
connect_signalr.yaml # SignalR connection tool
document_workflow.yaml # Workflow documentation generator
mypy_type_checker.yaml # Static type checking
python_syntax_validator.yaml # Syntax validation
run_static_analysis.yaml # Static analysis runner
save_to_disk.yaml # Disk persistence
signalr_hub_connector.yaml # Hub connection
signalr_websocket_stream.yaml # WebSocket streaming
unit_converter.yaml # Unit conversion utilities
Інструменти OpenAPI:
$ ls tools/openapi/
nmt_translator.yaml # Neural machine translation API
Загалом інструментів: 50+
Загалом рядків метаданих: 51644 рядки index.json
Дозвольте мені показати вам найскладніший інструмент у системі: code_optimizer.
Визначення: tools/llm/code_optimizer.yaml (317 рядків!)
Що він робить:
Ієрархічна оптимізація:
optimization_levels:
- name: "local"
model_key: "escalation" # qwen2.5-coder:14b
cost_usd: 0.0
expected_improvement: 0.10 # 10%
triggers:
- "Default for all optimizations"
- "Quick wins, obvious inefficiencies"
- name: "cloud"
model_key: "cloud_optimizer" # GPT-4/Claude
cost_usd: 0.50
expected_improvement: 0.30 # 30%
triggers:
- "Local improvement < 15%"
- "Code is critical path"
- "User explicitly requests it"
- name: "deep"
model_key: "deep_analyzer"
cost_usd: 5.0
expected_improvement: 0.50 # 50%
triggers:
- "Workflow/system-level optimization"
- "Cloud improvement < 25%"
- "Architectural changes needed"
Керування вартістю:
cost_management:
max_daily_budget: 50.0 # USD
fallback_on_budget_exceeded: "local"
optimization_strategy: |
1. Always try LOCAL first (free)
2. Escalate to CLOUD if:
- Local improvement < 15%
- Reuse count > 100
3. Escalate to DEEP if:
- Cloud improvement < 25%
- System-level changes needed
Інтеграція тесту:
test_integration:
auto_update: true
test_discovery:
- "Find test_*.py in tests/"
- "Identify tests for specific functions"
test_generation:
- "Generate missing tests"
- "Add performance assertions"
- "Create regression tests"
Керування версіями:
version_management:
semver: true
breaking_change_detection:
- "Function signature changed"
- "Return type changed"
- "Dependencies added/removed"
auto_migration:
enabled: true
conditions:
- "No breaking changes"
- "All tests pass"
- "Improvement >= 10%"
Це один інструмент оркестри:
І це лише один інструмент у системі за допомогою 50+ інструменти.
Один з найбільш метаінструментів: mode_ selector.
Вибір природної мови:
# User says: "using the most powerful code llm review this code"
selection = tools_manager.invoke_llm_tool(
tool_id="model_selector",
prompt="using the most powerful code llm review this code"
)
# Result:
{
"backend": "anthropic",
"model": "claude-3-opus-20240229",
"reasoning": "Request specifies 'most powerful'. Claude Opus is the highest-quality code model.",
"confidence": 0.95,
"cost_tier": "very-high",
"speed_tier": "slow",
"quality_tier": "exceptional"
}
Як це працює:
def select_model(
self,
task_description: str,
constraints: Optional[Dict[str, Any]] = None
) -> List[Dict[str, Any]]:
"""Select best model for task."""
task_lower = task_description.lower()
# Parse natural language preferences
backend_preference = None
if any(kw in task_lower for kw in ["openai", "gpt"]):
backend_preference = "openai"
elif any(kw in task_lower for kw in ["anthropic", "claude"]):
backend_preference = "anthropic"
# Parse model preference
model_preference = None
if "gpt-4o" in task_lower:
model_preference = "gpt-4o"
elif "opus" in task_lower:
model_preference = "opus"
# Analyze task characteristics
needs_long_context = any(w in task_lower for w in
["book", "novel", "document", "large", "long"])
needs_coding = any(w in task_lower for w in
["code", "function", "script", "program"])
needs_speed = any(w in task_lower for w in
["quick", "fast", "immediate"])
needs_quality = any(w in task_lower for w in
["complex", "analysis", "reasoning"])
# Score each model
scores = {}
for backend_model_id, info in self.backends.items():
score = 50.0 # Base
# Backend preference
if backend_preference and info["backend"] == backend_preference:
score += 50
# Model preference
if model_preference and model_preference in info["model"].lower():
score += 100 # Strong boost
# Context window
if needs_long_context:
context = info.get("context_window", 8192)
if context >= 100000:
score += 40
# Speed
if needs_speed:
if info["speed"] == "very-fast":
score += 30
# Quality
if needs_quality:
if info["quality"] == "excellent":
score += 30
# Specialization
if needs_coding:
if "code" in info.get("best_for", []):
score += 35
scores[backend_model_id] = score
# Return top-ranked models
ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)
return [self.backends[bid] for bid, score in ranked[:3]]
Система інтерпретує природну мову. для вибору моделей. Можна сказати:
І він інтелектуально прямує до правильного сервера.
Система використовує зовнішні API так само, як внутрішні інструменти.
Приклад: NMT Translator
name: "NMT Translation Service"
type: "openapi"
description: "Neural machine translation API. VERY FAST but needs validation."
cost_tier: "low"
speed_tier: "very-fast"
quality_tier: "good"
openapi:
spec_url: "http://localhost:8000/openapi.json"
base_url: "http://localhost:8000"
code_template: |
import requests
def translate_text(text, source_lang="en", target_lang="de"):
url = "http://localhost:8000/translate"
params = {
"text": text,
"source_lang": source_lang,
"target_lang": target_lang
}
response = requests.get(url, params=params)
return response.json()["translations"][0]
tags: ["translation", "nmt", "api", "external"]
Під час запуску:
# System loads OpenAPI spec
openapi_tool = OpenAPITool(
tool_id="nmt_translator",
spec_url="http://localhost:8000/openapi.json"
)
# Parses operations
operations = openapi_tool.list_operations()
# [
# {"operation_id": "translate", "method": "GET", "path": "/translate"},
# {"operation_id": "get_languages", "method": "GET", "path": "/languages"}
# ]
# Invoke
result = tools_manager.invoke_openapi_tool(
"nmt_translator",
"translate",
parameters={"text": "hello", "source_lang": "en", "target_lang": "de"}
)
# Result: {"success": True, "data": {"translations": ["Hallo"]}}
За чим слідкують:
# Stored in RAG:
{
"artifact_type": "API_INVOCATION",
"tool_id": "nmt_translator",
"operation_id": "translate",
"status_code": 200,
"success": True,
"latency_ms": 124,
"parameters": {"text": "hello", "source_lang": "en", "target_lang": "de"},
"response": {"translations": ["Hallo"]}
}
Зовнішні API отримують таке ж лікування:
Один з найдикіших інструментів: workflow_ documenter.
Що він робить:
Виконує процес (a main.py файл) і автоматично створює комплексну документацію на:
README.txtВсе автоматично.
Визначення: tools/llm/workflow_documenter.yaml (11 803 символи!)
Ввід:
{
"workflow_path": "nodes/email_validator/main.py"
}
Вивід:
## Overview
Validates email addresses and optionally checks domain matching.
## What It Does
This workflow checks if an email address is valid using regex.
If you provide a domain, it checks if the email belongs to that domain.
## Required Inputs
- **email** (string, required)
- The email address to validate
- Example: "user@example.com"
- **domain** (string, optional)
- The domain to check against
- Example: "example.com"
## Process Flow
```mermaid
flowchart TD
A[Start: Receive Input] --> B[Extract email and domain]
B --> C{Email provided?}
C -->|No| D[Error: email required]
C -->|Yes| E[Validate email format]
E --> F{Valid format?}
F -->|No| G[Return: invalid]
F -->|Yes| H{Domain provided?}
H -->|No| I[Return: valid]
H -->|Yes| J[Extract email domain]
J --> K{Domains match?}
K -->|Yes| I
K -->|No| L[Return: domain_mismatch]
curl -X POST http://localhost:8080/execute/email_validator \
-H "Content-Type: application/json" \
-d '{"email": "user@example.com", "domain": "example.com"}'
result = call_tool("email_validator", {
"email": "user@example.com",
"domain": "example.com"
})
П: Чи можна перевірити, чи існує електронна пошта? A: Ні, цей формат лише підтверджує формат. Для існування скористайтеся перевіркою DNS/ SMTP.
П: Чи підтримує він міжнародні володіння? В: Так, але може бути потрібне перетворення bindycode.
**Saved to:** `nodes/email_validator/README.txt`
**The tool GENERATES ALL OF THIS** by analyzing the code.
## The Self-Expanding Toolkit
Here's where it gets wild: **tools generate tools**.
**Example Flow:**
Користувач: " Мені потрібен інструмент, який перетворює температуру "
Система:
Створено новий інструмент: температура_ converter. ayaml
**The system grows its own toolkit.**
## Tool Statistics: What The System Knows
```python
stats = tools_manager.get_statistics()
# Result:
{
"total_tools": 53,
"by_type": {
"llm": 27,
"executable": 19,
"openapi": 3,
"workflow": 2,
"custom": 2
},
"tag_distribution": {
"code": 15,
"validation": 12,
"translation": 8,
"optimization": 5,
"documentation": 4,
...
},
"most_used": [
{"id": "general", "name": "General Purpose LLM", "usage": 1247},
{"id": "code_optimizer", "name": "Code Optimizer", "usage": 89},
{"id": "nmt_translator", "name": "NMT Translator", "usage": 67},
{"id": "email_validator", "name": "Email Validator", "usage": 45},
{"id": "long_form_writer", "name": "Long-Form Writer", "usage": 23}
]
}
Система знає:
І це використовувати ці дані до:
Давайте відступимо назад і подумаємо про те, що ми збудували.
Система, де:
Ми створили інструмент самооптимізації, який:
Це не управління конфігурацією.
Це ентерантний інструмент екології.
Інструменти - це не статичні ресурси. живі речові пам'ятки в еволюційній системі.
Сценарій 1. Самоутвердження критичного шляху
System detects: email_validator used 500 times, fitness: 0.75
Action: Trigger code_optimizer with level=cloud (high reuse count)
Result: email_validator v2.0.0, fitness: 0.92
Migration: Auto-update all 15 workflows using v1.x to v2.0.0
Validation: Re-run all tests, all pass
Outcome: 23% performance improvement, no breaking changes
Система оптимізувала свій власний критичний шлях без втручання людини.
Сценарій 2: Адаптивна спеціалізація
Pattern detected: "translate article" requested 20 times
Analysis: Using nmt_translator + translation_quality_checker every time
Decision: Generate specialized "article_translator" tool
Implementation:
- Combines both tools into one
- Adds caching for common phrases
- Optimizes for article-length text
- Auto-generates documentation
Registration: article_translator v1.0.0 added to registry
Fitness: 0.89 (vs 0.73 for manual combination)
Usage: Immediately used for next translation request
Система визначила шаблон і створила спеціальний інструмент.
Сценарій 3: експлуатація вартості
Request: "optimize this function"
Level 1 (LOCAL): qwen2.5-coder:14b (free)
- Improvement: 8% (below 10% threshold)
- Decision: Escalate to CLOUD
Level 2 (CLOUD): claude-3-5-sonnet ($0.50)
- Improvement: 28% (good!)
- Cost: $0.50 (within budget)
- Decision: Accept
Result: Function optimized 28%, cost $0.50
Update: Store both versions in RAG
Mark v1 as "suboptimal", v2 as "optimized"
Future: Always use v2 for this function
Система витрачала гроші інтелігентно, щоб досягти кращих наслідків.
Дозвольте мені каталогізувати те, що насправді існує прямо зараз.
Спеціаліст коду
code_explainer - Обґрунтовує код природною мовоюcode_optimizer - Ієрархічна оптимізація (локальна/хмара/глибока)code_reviewer - Якість і перегляд безпекиfast_code_generator - Швидке створення з маленькими моделямиsecurity_auditor - Сканування вразливостіperformance_profiler - Синхронізація і аналіз кодуСпеціалісти вмісту:
long_form_writer - Нови, книги (128K контекст)content_generator - Загальний вмістarticle_analyzer - Структура/ Якість статейsummarizer - Підсумовує довгий зміст.proofreader - Граматика і стильseo_optimizer - Оптимізація SEOoutline_generator - Контури вмістуПереклад:
quick_translator - Швидкий переклад (маленька модель)translation_quality_checker - Перевіряє перекладиДокументація:
doc_generator - Документація з кодомtechnical_writer - Технічна документаціяworkflow_documenter - Автоматично створювати документи для роботиСистемні інструменти:
general - Загальна мета поверненняmodel_selector - Вибирає найкращий сервер/ режимtask_to_workflow_router - Маршрут для робочих маршрутівquick_feedback - Швидка тріжаsignalr_connection_parser - З' єднання SignR для аналізуsignalr_llmapi_management - Керує API LEDR LLMПеревірка:
call_tool_validator - Перевіряє використання call_ tools}python_syntax_validator - Перевірка синтаксисуmypy_type_checker - Статична перевірка типуjson_output_validator - Перевірка формату JSONstdin_usage_validator - Перевіряє використання stdinmain_function_checker - Перевіряє функцію main}node_runtime_import_validator - Перевіряє імпортАналіз:
run_static_analysis - Виконує інструменти статичного аналізуperformance_profiler - Профілі швидкодії кодуІнструменти:
save_to_disk - Наполегливість на дискахunit_converter - Перетворення одиницьrandom_data_generator - Створення тестових данихbuffer - Керування буферомworkflow_datastore - Сховище даних робочого процесуstream_processor - Обробка потокуsse_stream - Події, що надсилаються на серверІнтеграція:
connect_signalr - З' єднання з сигналомRsignalr_hub_connector - Об' єм з' єднанняsignalr_websocket_stream Потоковий потік WebSocketДокументація:
document_workflow - Генератор документації для роботиnmt_translator - Програмний інтерфейс для перекладу@ title: windowВсього: 53 інструменти (і ріст)
Ось де стає справді цікаво: інструменти, що складають інші інструменти.
І коли сконструйований інструмент розвивається, кожен робочий процес, що ним користується, автоматично поліпшується.
Давайте поглянемо на справді складний інструмент системи:
Завдання: "Перекласти цю статтю на іспанську і підтвердити якість"
Традиційний підхід:
# Manual composition (brittle, no learning)
translated = nmt_translator.translate(text, "en", "es")
quality = translation_quality_checker.check(translated)
if quality.score < 0.7:
# Retry or error
Прихід DSE:
Система відкриває цей шаблон часто і автоматично створює комп' ютерний інструмент:
# tools/llm/validated_translator.yaml (auto-generated!)
name: "Validated Translator"
type: "composite"
description: "Translates text and validates quality automatically. Created from usage pattern analysis."
workflow:
steps:
- id: "translate"
tool: "nmt_translator"
parallel: false
- id: "validate"
tool: "translation_quality_checker"
parallel: false
depends_on: ["translate"]
- id: "retry"
tool: "nmt_translator"
condition: "quality_score < 0.7"
params:
beam_size: 10 # Higher quality on retry
depends_on: ["validate"]
version: "1.0.0"
created_from: "usage_pattern_analysis"
parent_tools: ["nmt_translator", "translation_quality_checker"]
usage_count: 0 # Just created!
Що тут такого:
КОЛИ nmt_translator Поширюється до v2. 0. 0 (можливо 20% швидше), композитний інструмент автоматично використовує нову версіюНе потрібно змін у коді.
Результат: Всі робочі елементи, які використовують validated_translator отримує 20% швидше без будь- яких змін.
Ось ще крутіший приклад: паралельна композиція інструмента.
Завдання: "Докладно перегляньте цей код"
Наївний підхід:
# Sequential (SLOW)
security_check = security_auditor.review(code) # 8 seconds
style_check = code_reviewer.review(code) # 12 seconds
performance_check = performance_profiler.analyze(code) # 15 seconds
# TOTAL: 35 seconds
Паралельна композиція DSE:
# tools/llm/code_review_committee.yaml
name: "Code Review Committee"
type: "composite"
description: "Parallel code review using multiple specialist tools"
workflow:
steps:
# All three run IN PARALLEL
- id: "security"
tool: "security_auditor"
parallel: true
- id: "style"
tool: "code_reviewer"
parallel: true
- id: "performance"
tool: "performance_profiler"
parallel: true
# Aggregate results (runs after all complete)
- id: "aggregate"
tool: "general" # Use general LLM to synthesize
depends_on: ["security", "style", "performance"]
prompt: |
Synthesize these reviews into a cohesive report:
Security: {security.result}
Style: {style.result}
Performance: {performance.result}
Create a prioritized action list.
execution:
max_parallel: 3
timeout_per_tool: 20s
aggregate_timeout: 10s
Виконання:
gantt
title Code Review Committee (Parallel Execution)
dateFormat s
axisFormat %S
section Sequential (Old)
Security Check :0, 8s
Style Check :8, 12s
Performance Check :20, 15s
Total: 35s :35, 1s
section Parallel (New)
Security Check :0, 8s
Style Check :0, 12s
Performance Check :0, 15s
Aggregate Results :15, 5s
Total: 20s :20, 1s
Результат: 35 секунд → 20 секунд (43% швидше!)
І коли security_auditor Виходить до v3. 0. 0 (наприклад, 30% швидше), весь комітет автоматично пришвидшується.
Ось частина, яка дійсно дика: інструменти діють як гени.
Спостереження: Якщо інструмент виявиться корисним, він поширюється через систему.
Справжній приклад: приклад перевірки якості
Day 1: translation_quality_checker created
- Usage: 1 (manual test)
- Workflows using it: 0
Day 3: First workflow uses it (article_translator)
- Usage: 15
- Workflows: 1
- Fitness: 0.78
Day 7: Quality checker "gene" spreads
- Usage: 127
- Workflows using it: 7
1. article_translator
2. validated_translator (composite)
3. batch_translator
4. multilingual_content_generator
5. documentation_localizer
6. seo_multilingual_optimizer
7. chat_translator
- Fitness: 0.91 (improved through evolution!)
Day 14: Mutation detected
- translation_quality_checker v2.0.0
- Change: Added context-aware validation
- Breaking change: Output format different
- All 7 workflows auto-migrate
- New fitness: 0.94
Day 30: Specialization emerges
- Original tool spawns specialist: article_quality_checker
- Optimized specifically for article-length text
- 40% faster than general checker
- article_translator auto-switches to specialist
- General checker still used by other 6 workflows
Це буквальне генетичне поширення:
Шлях до коду - оптимальний ALWAYS, тому що:
Ось дійсно розумний момент: ви можете удосконалювати всі інструменти одночасно.
Сценарій: У вас 20 робочих потоків, кожен використовує 5-10 інструментів.
Традиційна система:
Workflow 1 uses Tool A v1.0 (fitness: 0.70)
Workflow 2 uses Tool A v1.0 (fitness: 0.70)
...
Workflow 20 uses Tool A v1.0 (fitness: 0.70)
To improve: Manually edit Tool A, test on each workflow (20 tests!)
Risk: Breaking changes affect all 20 workflows
Система DSE:
# Trigger evolution for Tool A
evolve_tool("translation_quality_checker")
# System automatically:
# 1. Analyzes usage patterns across all 20 workflows
# 2. Identifies common failure modes
# 3. Generates improved version (v2.0)
# 4. A/B tests v1.0 vs v2.0 on EACH workflow
# 5. Calculates fitness improvement per workflow
# 6. Auto-migrates workflows where v2.0 is better
# 7. Keeps v1.0 for workflows where v2.0 regresses
Результат:
Workflow 1: Tool A v2.0 (fitness: 0.85) ✓ Migrated
Workflow 2: Tool A v1.0 (fitness: 0.72) ✗ Kept old (v2 was worse)
Workflow 3: Tool A v2.0 (fitness: 0.89) ✓ Migrated
...
Workflow 20: Tool A v2.0 (fitness: 0.91) ✓ Migrated
Total migrated: 18/20 workflows (90%)
Average fitness improvement: +15%
Вы обучили один инструмент и улучшили ЭЙМЕЙН-отряд одновременно.
По-справжньому дика частина: Напрям еволюції через графік залежностей.
Приклад:
Tool: nmt_translator v1.0 (fitness: 0.73)
Used by:
- validated_translator (composite)
- article_translator
- batch_translator
- chat_translator
Evolution triggered: nmt_translator v1.0 → v2.0
Improvement: 25% faster, 10% better quality
Fitness: 0.73 → 0.88
Cascade effect:
1. validated_translator FITNESS: 0.82 → 0.91 (automatic!)
2. article_translator FITNESS: 0.79 → 0.87 (automatic!)
3. batch_translator FITNESS: 0.75 → 0.83 (automatic!)
4. chat_translator FITNESS: 0.71 → 0.78 (automatic!)
Tools using those tools ALSO improve:
- multilingual_content_generator: 0.76 → 0.84
- documentation_localizer: 0.81 → 0.88
- seo_multilingual_optimizer: 0.69 → 0.77
Total workflows improved: 11
Total time spent: 0 (automatic propagation!)
Total code changes: 0
Одна з подій, пов'язаних з теорією еволюції, поліпшила роботу ELEVEN без втручання людини.
Тому що інструменти стеження за фітнесом, результати кешування і автовипромінювання системи завжди виконує найкращу наявну реалізацію.
Приклад виконання:
User: "Translate this article to Spanish"
System thinks:
1. Search RAG for "translation" tools
→ Found: nmt_translator, validated_translator, quick_translator
2. Calculate fitness for this specific task:
- nmt_translator: 0.88 (fast, good quality)
- validated_translator: 0.91 (slower, validated)
- quick_translator: 0.76 (very fast, lower quality)
3. Task analysis:
- Input length: 2,500 words (long)
- Quality requirement: high (article)
- Speed requirement: medium (no rush)
4. Decision: Use validated_translator (highest fitness + quality match)
5. Check cache:
- Cache key: hash(tool_id + normalized_prompt)
- Found: 3 cached results
- v1.0 (fitness: 0.82, age: 5 days)
- v1.1 (fitness: 0.89, age: 2 days)
- v2.0 (fitness: 0.91, age: 1 hour)
- Select: v2.0 (highest fitness, most recent)
6. Execute: Return cached v2.0 result (INSTANT)
7. Update metrics:
- validated_translator.usage_count++
- validated_translator.cache_hits++
- validated_translator.avg_latency_ms (no change, cache hit)
Система:
Шлях до коду оптимізовано на кожному кроці:
Давайте будемо точними щодо того, чому це так. штучна еволюція а не просто " cacheching with versioning ":
Інструменти як гени:
class Tool:
"""A tool is a genetic unit that:
- Replicates (used by multiple workflows)
- Mutates (evolves to new versions)
- Competes (fitness-based selection)
- Specializes (variants emerge)
- Dies (low-fitness tools pruned)
"""
# Genetic material
definition_hash: str # "DNA"
version: str # Generational marker
lineage: List[str] # Ancestry
# Replication rate
usage_count: int # How many "offspring"
workflows_using: int # Spread through ecosystem
# Fitness
quality_score: float # Survival metric
performance_metrics: Dict # Selection pressure
# Mutation
breaking_changes: List # Genetic incompatibility
evolution_history: List # Mutation record
Пряма еволюція:
# Unlike natural selection (random mutations),
# DSE uses DIRECTED mutations based on data:
def evolve_tool(tool_id: str):
"""Directed evolution with learning."""
# Analyze failure modes across ALL usage
failures = analyze_tool_failures(tool_id)
# "This tool fails when input > 5000 tokens"
# Generate targeted improvement
improvement_spec = create_improvement_plan(failures)
# "Add chunking for inputs > 5000 tokens"
# Mutate with purpose
new_version = apply_directed_mutation(tool_id, improvement_spec)
# Test fitness
fitness_improvement = a_b_test(old_version, new_version)
# Selection
if fitness_improvement > threshold:
promote_version(new_version) # Survives
else:
discard_version(new_version) # Dies
"Гене- Пул":
53 tools in registry (current generation)
├── 27 LLM tools (specialist genes)
├── 19 executable tools (utility genes)
├── 3 OpenAPI tools (external interface genes)
├── 4 composite tools (multi-gene complexes)
Total genetic variations across versions: ~200+
Active in current generation: 53
Archived (evolutionary dead-ends): ~150
Візуалізація генетичного поширення:
graph TB
T1["nmt_translator v1.0<br/>Fitness: 0.73<br/>Usage: 5"] --> T2["nmt_translator v2.0<br/>Fitness: 0.88<br/>Usage: 127"]
T2 --> W1["validated_translator<br/>Composite: nmt + quality<br/>Fitness: 0.91"]
T2 --> W2["article_translator<br/>Uses: nmt<br/>Fitness: 0.87"]
T2 --> W3["batch_translator<br/>Uses: nmt<br/>Fitness: 0.83"]
W1 --> U1["multilingual_content<br/>Uses: validated<br/>Fitness: 0.84"]
W1 --> U2["doc_localizer<br/>Uses: validated<br/>Fitness: 0.88"]
T2 -.->|Mutation| T3["nmt_translator v3.0<br/>Specialization: articles<br/>Fitness: 0.94"]
T3 --> W2
style T1 fill:#ffcccc
style T2 fill:#ccffcc
style T3 fill:#ccccff
style W1 fill:#ffffcc
style W2 fill:#ffffcc
style W3 fill:#ffffcc
style U1 fill:#ffeecc
style U2 fill:#ffeecc
Генетична спадщина:
# Child tool inherits from parent
article_quality_checker:
parent: translation_quality_checker
inherited_attributes:
- quality_metrics
- validation_patterns
- error_detection
mutations:
- "Specialized for article-length text"
- "Added domain-specific checks"
- "40% faster (optimized for articles)"
fitness_inheritance:
parent_fitness: 0.91
child_fitness: 0.94 # Improvement!
selection_advantage:
- Chosen over parent for article tasks
- Parent still used for general translation
Неа, да?
Так, справді дика.
Ми побудували систему, де:
Це не метафора.
Це насправді штучна еволюція.
Після запуску цієї системи декілька тижнів:
Якщо інструменти можуть:
Що далі?
Ось, що частина 7 не повністю пояснила:
Вони зроблені з інструментів. Інструменти, що складають робочі потоки? Вони також розвиваються. Система, що керує еволюцією? Норми, що відстежують придатність? Так, інструменти.
Це інструменти до самого низу.
І кожен:
Ми не створили генератор коду.
Ми створили самоекспонуючий, самооптимізуючий інструмент самодослідження, який створює код.
Різниця важлива.
Тому що коли інструменти стають еволюційними одиницями, коли вони відстежують свою власну пристосованість, коли вони розмножуються, мутують і конкурують...
У вас немає панелі інструментів.
У вас екологія.
І екологія розвивається.
Але що стається, коли еволюція ламає речі? Коли інструмент вводить в дію критичну ваду? Коли оптимізація погіршує інструмент, а не покращує його?
Ось до чого входить частина 9. Самозцілення через свідоме обрізанняУ системі, де інструменти не просто розвиваються, вони пам'ятають кожну невдачу, підрізають гілки і поширюють це знання, щоб запобігти подібним помилкам по всій екосистемі.
Коли твої інструменти можуть зламатися, твоя система повинна пам'ятати чому і ніколи не повторювати помилки.
Сховище: three locid.dse
Файли ключів:
src/tools_manager.py (2 293 рядки) - керування інструментами ядраsrc/rag_integrated_tools.py (562 рядків) - Інтеграція RAGsrc/openapi_tool.py (313 рядків) - підтримка OpenAPIsrc/model_selector_tool.py (460 рядків) - Вибір моделіtools/index.json (5 644 рядки) - реєстр інструментівtools/llm/*.yaml (27 інструментів) - Визначення LLMtools/executable/*.yaml (19 інструменти) - програми для роботиtools/openapi/*.yaml (3 інструменти) - інтеграція з APIДокументація:
LLMS_AS_TOOLS.md - Система вибору LLMWORKFLOW_DOCUMENTATION_TOOL.md - АвтодокументаціяCHAT_TOOLS_GUIDE.md - Довідник з використання інструментівTOOL_PACKAGING.md - Інструкція для розробки інструментівНавігація серією:
Це частина 8 у серії семантичних розвідувачів. Частина 7 показала загальну архітектуру DSE. У цій статті показано приховану складність: кожен інструмент у системі використання доріжок, розвиток реалізації, результати кешування і участь у відборі, заснованому на придатності. Набір інструментів - це не просто ресурс, який починає розширюватися, оптимізується і сам документ. Інструменти Створити інструменти. Інструменти Удосконалення інструментів. Уся система з часом стає розумнішим.
Код є справжнім, працює локально на Ollama, істинно відстежуючих вимірах і фактично розвивається. він експериментальний, іноді нестабільний і однозначно "зкодований." але інструменти працюють, слідкування працюють, і еволюція працює. інструментальне поле росте сам по собі.
Ці дослідження з' єднуються з романом Sci- fi, який працює у стилі "Mache" про емісійний комп' ютер та наслідки систем, які оптимізують себе. Описані тут, - це реальні реалізації, які показують, як еволюційний тиск створює спеціалізацію, як функціонування функцій для вибору, і як самоудосконалені системи природно розробляють екологічні властивості. Незалежно від того, чи це призводить до мережі інструментів планетарного масштабу, що складається з 6- ї частини, чи щось абсолютно неочікуване, залишається видимим. Саме це і робить його експериментом.
Мітки: #AI #Tools #RAG #UsageTracking #Evolution #Fitness #Caching #Versioning #Ollama #Python #EmergentIntelligence #SelfOptimization #ToolEcology
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.