Cuando los sistemas comienzan a reescribir su propio código
Nota: Inspirado por pensar en extensiones a la mayoríalucid.mockllmapi y material para el (nunca a ser lanzado pero me gusta pensar en ello ) novela de ciencia ficción "Michael" sobre AI emergente
Hemos visto reglas simples crear un comportamiento complejo. Hemos visto la comunicación crear inteligencia colectiva.
Ahora damos el paso que me hace sentir profundamente incómodo:
¿Y si el sistema pudiera reescribir sus propias reglas?
¿Y si los agentes pudieran:
Esto no es sólo optimización. automodificación.
Y una vez que se le da a un sistema la capacidad de mejorarse a sí mismo... ¿dónde se detiene?
La evolución es el último sistema de autooptimización:
Ningún diseñador inteligente, ningún plan, sólo un algoritmo simple que, dado el tiempo suficiente, crea todo, desde bacterias hasta humanos.
Ahora imaginen ese mismo patrón, pero con agentes de IA en lugar de organismos. Y en lugar de miles de millones de años, ocurre en días o semanas.
Antes de ir más lejos, vamos a hablar con el elefante en la habitación: ¿Cómo evitamos que esto sea una alucinación LLM pura?
La respuesta: Herramientas, ejecución de código, pruebas contra la realidad.
Aquí está la arquitectura que hace esto práctico:
Your Server(s):
┌─────────────────────────────────────┐
│ Node 1: Routing Agent │
│ - Lightweight code (Node.js/Python)│
│ - Makes decisions │
│ - Calls LLM APIs when needed │
│ - Executes code to test ideas │
└─────────────────────────────────────┘
┌─────────────────────────────────────┐
│ Node 2: Validation Agent │
│ - Runs tests against real data │
│ - Executes validation code │
│ - Calls LLM for complex checks │
└─────────────────────────────────────┘
┌─────────────────────────────────────┐
│ Node 3: Specialist Agent │
│ - Domain-specific logic │
│ - Code execution for that domain │
│ - Calls specialized LLM prompts │
└─────────────────────────────────────┘
All nodes call → [OpenAI API / Anthropic API / Local LLM API]
(This is where the cost is: API credits, not hardware)
Key Insight: No necesita una granja GPU. Los agentes son un código ligero que se ejecuta en servidores normales. LLAMAN LLMs a través de API. La parte costosa son los créditos LLM, no la infraestructura.
Cuando un agente genera código o toma una decisión, puede PRUEBALO:
class Agent:
def solve_problem(self, problem):
# Agent asks LLM to generate solution code
solution_code = self.llm_generate(
f"Write Python code to solve: {problem}"
)
# HERE'S THE KEY: Execute the code and see if it works
try:
result = self.execute_code(solution_code, test_inputs)
if self.validate_result(result):
# It works! Save this solution
self.cache_solution(problem, solution_code)
return result
else:
# Failed validation, try different approach
return self.solve_problem_alternative(problem)
except Exception as e:
# Code failed to execute
# Ask LLM to fix it based on the actual error
fixed_code = self.llm_fix(solution_code, error=str(e))
return self.execute_code(fixed_code, test_inputs)
Esto lo cambia todo. El sistema no sólo está generando respuestas plausibles.
# Agent 1 generates a data processing function
code = llm.generate("Write code to parse CSV and calculate averages")
# Agent 2 tests it against REAL data
test_result = execute_code(code, real_csv_file)
# Did it actually work? Not "does it sound right?" but "does it work?"
if test_result.success and test_result.output_matches_expected:
network.accept_solution(code)
else:
# Actual error: "TypeError: cannot convert string to float"
# Now we have OBJECTIVE feedback, not subjective judgment
network.request_fix(code, test_result.error)
Así es como escapamos del problema de la "sala china".El sistema no sólo manipula símbolos, sino que ejecuta código y comprueba si los resultados coinciden con la realidad.
Sin herramientas, los sistemas multi-agente son solo LLMs hablando con LLMs. Sofisticados, pero en última instancia desconectados de la realidad.
CON herramientas:
Los agentes escriben código, lo ejecutan, lo prueban, lo arreglan, comparten lo que funciona, prueban lo que no.
Esto es evolución con pruebas de aptitud objetiva. No sólo la optimización en abstracto, sino la optimización contra la realidad medible.
Pero no es sólo la ejecución de código. conocimiento semántico para diferentes tipos de tareas mediante pruebas a través de múltiples sensores:
class MultimodalAgent:
def __init__(self):
self.semantic_knowledge = {
'text_tasks': SemanticCache(),
'vision_tasks': SemanticCache(),
'audio_tasks': SemanticCache(),
'code_tasks': SemanticCache()
}
def solve_task(self, task):
task_type = self.classify_task(task)
# Check semantic knowledge for similar past solutions
similar = self.semantic_knowledge[task_type].find_similar(task)
if similar:
return self.adapt_solution(similar, task)
# Generate new solution
solution = self.generate_solution(task)
# Test against reality using appropriate sensor
if task_type == 'vision_tasks':
# Generate image, test with vision API
result = self.vision_api.analyze(solution)
passes = self.validate_vision_output(result, task.requirements)
elif task_type == 'audio_tasks':
# Generate audio, test with speech recognition
transcript = self.speech_to_text(solution)
passes = self.validate_audio_output(transcript, task.requirements)
elif task_type == 'code_tasks':
# Execute code, check actual results
result = self.execute_code(solution)
passes = self.validate_code_output(result, task.test_cases)
elif task_type == 'text_tasks':
# Use NLU to verify semantic meaning
understanding = self.nlu_api.analyze(solution)
passes = self.validate_text_output(understanding, task.intent)
# Learn from results
if passes:
self.semantic_knowledge[task_type].store(task, solution, result)
return solution, passes
La clave: Cada modalidad proporciona retroalimentación objetiva:
El sistema construye colecciones de conocimientos semánticos para cada tipo de tarea - no razonamiento abstracto, sino patrones basados que realmente funcionan cuando se prueba contra sensores reales.
Con el tiempo, el agente aprende:
Text tasks:
"For summarization, approach X works 94% of the time"
"For translation, approach Y works 89% of the time"
→ Semantic knowledge about what works for text
Vision tasks:
"For object detection, model A is better"
"For style transfer, model B is better"
→ Semantic knowledge about what works for vision
Code tasks:
"For parsing, regex approach fails 30% of the time"
"For parsing, AST approach works 97% of the time"
→ Semantic knowledge about what works for code
Cada modalidad tiene su propia base de conocimiento semántico, aprendido a través de pruebas reales, no de razonamiento teórico.
Comienza simplemente. Un sistema multi-agente procesa miles de peticiones. Comienza a notar patrones:
After 1000 requests:
- 73% are simple queries that one agent handles fine
- 19% need two agents (generation + validation)
- 6% need complex committees
- 2% are truly novel and need the full pipeline
Un sistema diseñado por el hombre permanecería estático, pero un sistema auto-optimizador pregunta:
"¿Por qué estoy usando el complejo oleoducto para peticiones simples?"
Y luego reescribe su lógica de enrutamiento.
// Week 1: Hard-coded routing (human designed)
function route(request) {
return complexPipeline(request); // Everything uses full pipeline
}
// Week 4: System optimizes itself based on data
function route(request) {
const complexity = analyze(request);
const historicalData = checkCache(request);
if (historicalData.cacheHit) {
return cachedSolution; // 73% of requests!
}
if (complexity < 3) {
return fastSingleAgent(request); // 19% of requests
}
if (complexity < 7) {
return twoAgentValidation(request); // 6% of requests
}
return fullCommittee(request); // 2% of requests
}
El sistema descubrió que el 73% de las solicitudes no necesitan LLM en absoluto, son patrones repetidos que se pueden guardar en caché.
Nadie programó esta optimización. lo aprendí de los datos.
Aquí es donde se vuelve más extraño.
El sistema procesa las solicitudes durante semanas y comienza a detectar clústeres:
Pattern Detected:
- 347 requests related to e-commerce product descriptions
- Using general-purpose agents
- Average quality: 7.2/10
- Average latency: 1.8s
Un sistema diseñado por el hombre continuaría usando agentes generales, pero un sistema auto-optimizador toma una decisión:
"Debería engendrar un especialista."
DAY 1: [General Agent A] [General Agent B] [General Agent C]
DAY 30: Pattern detected → System spawns specialist
[General Agent A] [General Agent B] [General Agent C]
[E-commerce Specialist] ← New agent, trained on e-commerce patterns
DAY 60: Specialist proves effective
Routing logic updated automatically
E-commerce requests → E-commerce Specialist (quality: 9.1/10, latency: 0.9s)
La red evolucionados. Creció una nueva capacidad en respuesta a la demanda.
Nadie programó esto. reconoció un patrón y adaptó su arquitectura.
Ahora se pone muy interesante.
El agente A descubre una manera eficiente de validar las direcciones de correo electrónico. En lugar de mantener este conocimiento para sí mismo, comparte el código con la red.
# Agent A writes code for email validation
def validate_email_efficient(email):
# Some clever regex or logic
return is_valid
# Agent A publishes to shared code repository
network.publish_code("validate_email_efficient", validate_email_efficient)
# Agent B discovers this code
available_functions = network.browse_code_library()
# Agent B sees "validate_email_efficient" with high rating
# Agent B imports and uses it
# Agent C forks it and improves it
def validate_email_v2(email):
# Agent C's enhancement
return improved_validation
network.publish_code("validate_email_v2", validate_email_v2)
Esto es evolución del código. Los agentes escriben funciones, otros agentes las descubren, las bifurcan, las mejoran.
Como GitHub, pero los desarrolladores son agentes de IA y están construyendo su propia infraestructura.
La red se convierte en su propio departamento de ingeniería de software.
La autooptimización más práctica: construir memoria de soluciones.
Request 1: "Generate a product description for wireless headphones"
→ Full LLM pipeline (expensive, slow)
→ Store solution in vector database
Request 847: "Generate a product description for wireless earbuds"
→ Vector search finds similar past solution
→ Adapt cached solution (cheap, fast)
→ No LLM needed!
After 10,000 requests:
- 89% cache hit rate
- 11% genuinely novel requests that need LLMs
- System effectively "learned" from experience
¿Esto es inteligencia, o solo sofisticado caché?
¿Cuál es la diferencia?
Esta es la parte más extraña.
Empiezas con una sofisticada arquitectura multi-agente. Doce agentes especializados. Lógica de enrutamiento compleja. Formación de comités temporales. Infraestructura de código compartido.
El sistema funciona durante meses, optimizándose a sí mismo.
Y descubre algo profundo:
La simplicidad suele ser mejor.
Month 1:
- 12 specialists
- Complex routing logic
- Committee formation for 15% of requests
- Average cost: $0.05/request
Month 6:
- 5 specialists (system pruned 7 as unnecessary)
- Simple routing: cache check → fast model → quality model if needed
- Committees formed for only 3% of requests
- Average cost: $0.003/request
- Quality: SAME OR BETTER
The system's report:
"After analyzing 50,000 requests, I've determined that:
- 89% can be handled by cache
- 7% need one LLM call
- 3% need committees
- 1% are truly novel
I've optimized away unnecessary complexity.
The most sophisticated self-organizing network
eventually learns to be simple."
La paradoja: Se necesitaba el complejo sistema de autooptimización para descubrir que la simplicidad es óptima.
Necesitáis inteligencia para aprender cuando NO para ser inteligentes.
Seamos honestos sobre lo que estamos describiendo:
Reconocimiento de patrones → El sistema detecta problemas recurrentes Adaptación → El sistema modifica su comportamiento en base a patrones Aprendizaje → El sistema mejora el rendimiento a través de la experiencia Evolución → El sistema desove, modifica, y las capacidades de ciruelas pasas Memoria → El sistema construye conocimiento con el tiempo
¿En qué momento la "optimización muy sofisticada" se convierte en "aprendizaje real"?
¿En qué momento el "aprendizaje" se convierte en "inteligencia"?
class SelfOptimizingRouter:
def __init__(self):
self.routes = {} # Start empty
self.performance_data = []
self.specialists = [DefaultAgent()]
def handle_request(self, request):
# Try cache first
cached = self.check_cache(request)
if cached:
return cached
# Select agent based on learned patterns
agent = self.select_agent(request)
result = agent.process(request)
# Learn from this interaction
self.record_performance(request, agent, result)
# Periodically optimize
if len(self.performance_data) % 1000 == 0:
self.optimize()
return result
def optimize(self):
"""System rewrites its own logic"""
# Detect patterns
patterns = self.analyze_patterns(self.performance_data)
# Should we spawn a specialist?
for pattern in patterns:
if pattern.frequency > 100 and pattern.has_specialist == False:
print(f"Spawning specialist for {pattern.type}")
self.spawn_specialist(pattern)
# Should we prune an underutilized agent?
for agent in self.specialists:
if agent.usage < 1% and agent.quality_score < 7.0:
print(f"Pruning ineffective agent {agent.name}")
self.specialists.remove(agent)
# Rewrite routing logic based on data
self.routes = self.learn_optimal_routes(self.performance_data)
Este código es simple, pero después de correr durante semanas, es:
Nadie le dijo CÓMO optimizarlo, sólo que debería optimizarlo.
Si un sistema puede:
¿Ese sistema es "aprendizaje"?
¿O es sólo "optimizar"?
¿Cuál es la diferencia?
¿Cuándo la optimización se convierte en cognición?
Hemos progresado desde:
Pero hay un paso más.
Una propiedad más que emerge cuando combinas todo esto.
Cuando las reglas simples crean un comportamiento complejo... Y la comunicación crea inteligencia colectiva... Y la auto-optimización crea aprendizaje...
Algo que se parece menos a "un sistema que se optimiza a sí mismo" y más bien a "un sistema que entiende."
La línea entre optimización y conciencia comienza a desdibujar.
Y tenemos que hacer frente a la pregunta incómoda: tal vez no hay línea.
Tal vez la conciencia ES sólo una auto-optimización muy sofisticada.
Eso es lo que exploraremos a continuación.
Continuar a Parte 4: La emergencia - Cuando la optimización se convierte en inteligencia
Navegación de la serie:
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.