Quando i sistemi iniziano a riscrivere il proprio codice
Nota: Ispirato dal pensiero di estensioni per lo piùlucid.mockllmapi e materiale per il (non essere mai rilasciato, ma mi piace pensarci) romanzo fantascientifico "Michael" su emergent AI
Abbiamo visto semplici regole creare comportamenti complessi. Abbiamo visto la comunicazione creare intelligenza collettiva.
Ora facciamo il passo che mi mette profondamente a disagio:
E se il sistema potesse riscrivere le proprie regole?
E se gli agenti potessero:
Non e' solo un'ottimizzazione. auto-modifica.
E una volta che si dà un sistema la capacità di migliorare se stesso... dove si ferma?
L'evoluzione è l'ultimo sistema di autoottimizzazione:
Nessun designer intelligente, nessun piano, solo un semplice algoritmo che, con il tempo sufficiente, crea tutto, dai batteri agli umani.
Immaginate lo stesso schema, ma con gli agenti AI invece che con gli organismi, e invece di miliardi di anni, succede in giorni o settimane.
Prima di andare oltre, rivolgiamoci all'elefante nella stanza: Come possiamo evitare che questo sia un'allucinazione pura dell'LLM?
La risposta: Strumenti. Esecuzione del codice. Prova contro la realtà.
Ecco l'architettura che lo rende pratico:
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)
Insight chiave: Non hai bisogno di una fattoria GPU. Gli agenti sono codice leggero in esecuzione su server normali. Chiamano LLMs tramite API. La parte costosa è crediti LLM, non infrastruttura.
Quando un agente genera un codice o prende una decisione, può provarlo:
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)
Questo cambia tutto. Il sistema non sta solo generando risposte plausibili.
# 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)
Questo è il modo in cui si evade il problema "Cinese Room." Il sistema non è solo manipolare i simboli che esegue il codice e controllare se i risultati corrispondono alla realtà.
Senza strumenti, i sistemi multi-agent sono solo LLMs che parlano con LLMs. Sofisticato, ma alla fine untethered dalla realtà.
CON gli strumenti:
Gli agenti scrivono il codice. Eseguilo. Provalo. Correggilo. Condividi ciò che funziona. Prune ciò che non funziona.
Questo e' evoluzione con test di idoneità obiettivi. Non solo l'ottimizzazione in astratto, ma l'ottimizzazione contro la realtà misurabile.
Ma non è solo l'esecuzione del codice. Il sistema può costruire conoscenza semantica per diversi tipi di attività mediante test attraverso sensori multipli:
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 chiave: Ogni modalità fornisce un feedback obiettivo:
Il sistema costruisce collezioni di conoscenze semantiche per ogni tipo di attività - non ragionamento astratto, ma modelli di base che funzionano effettivamente quando testati contro sensori reali.
Nel corso del tempo, l'agente impara:
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
Ogni modalità ha una propria base di conoscenze semantiche, imparate attraverso prove reali, non ragionamenti teorici.
Inizia semplicemente. Un sistema multi-agente elabora migliaia di richieste. Inizia notando i modelli:
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 progettato dall'uomo rimarrebbe statico, ma un sistema che si autoottimizza chiede:
"Perché sto usando la complessa pipeline per richieste semplici?"
E poi riscrive la sua logica di routing.
// 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
}
Il sistema ha scoperto che il 73% delle richieste non hanno bisogno di LLM a tutti sono modelli di ripetizione che possono essere cached.
Nessuno ha programmato questa ottimizzazione. l'ho imparato dai dati.
Qui e' dove diventa sconosciuto.
Il sistema elabora le richieste per settimane. Inizia a rilevare i cluster:
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 progettato dall'uomo continuerebbe ad usare agenti generali, ma un sistema che si auto-ottimizza prende una decisione:
"Dovrei deporre uno specialista."
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 rete evoluto. Ha sviluppato una nuova capacità in risposta alla domanda.
Nessuno l'ha programmato. riconosciuto un modello e adattato la sua architettura.
Ora diventa davvero interessante.
Agente A scopre un modo efficiente per convalidare gli indirizzi e-mail. Invece di mantenere questa conoscenza a se stesso, condivide il codice con la rete.
# 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)
Questo e' evoluzione del codice. Agenti scrivono funzioni, altri agenti li scoprono, li forchettano, li migliorano.
Come GitHub, ma gli sviluppatori sono agenti AI e stanno costruendo la propria infrastruttura.
La rete diventa il proprio dipartimento di ingegneria software.
L'autoottimizzazione più pratica: costruire la memoria delle soluzioni.
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
Questa e' intelligenza, o solo sofisticata cache?
Che differenza fa?
Ecco la parte piu' strana.
Iniziate con una sofisticata architettura multi-agent. Dodici agenti specializzati. Logica di routing complessa. Formazione temporanea del comitato. Infrastrutture di code-sharing.
Il sistema funziona per mesi, ottimizzando se stesso.
E scopre qualcosa di profondo:
La semplicità è di solito migliore.
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."
Il paradosso: Avete bisogno del complesso sistema di auto-ottimizzazione per scoprire che la semplicità è ottimale.
Avevi bisogno di intelligenza per imparare quando NON essere intelligente.
Siamo onesti su quello che stiamo descrivendo:
Riconoscimento modello → Il sistema rileva problemi ricorrenti Adeguamento → Il sistema modifica il suo comportamento in base ai modelli Apprendimento → Il sistema migliora le prestazioni attraverso l'esperienza Evoluzione → Il sistema depone, modifica e pota le capacità Memoria → Il sistema costruisce la conoscenza nel tempo
A che punto "l'ottimizzazione molto sofisticata" diventa "l'apprendimento effettivo"?
A che punto "imparare" diventa "intelligenza"?
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)
Questo codice è semplice. Ma dopo aver funzionato per settimane, è:
Nessuno gli ha detto come ottimizzare. Solo che dovrebbe ottimizzare.
Se un sistema può:
Questo sistema è "apprendimento"?
O e' solo "ottimizzare"?
Che differenza fa?
Quando l'ottimizzazione diventa cognizione?
Abbiamo fatto progressi da:
Ma c'e' un altro passo.
Un'altra proprietà che emerge quando si combinano tutti questi.
Quando le semplici regole creano un comportamento complesso... E la comunicazione crea intelligenza collettiva... E l'auto-ottimizzazione crea apprendimento...
Emerge qualcos'altro. Qualcosa che assomiglia meno a "un sistema che ottimizza se stesso" e più a "un sistema che capisce."
La linea tra ottimizzazione e coscienza inizia a sfumare.
E dobbiamo affrontare la domanda scomoda: forse non c'è linea.
Forse la coscienza è solo un'autoottimizzazione molto sofisticata.
E' quello che esploreremo dopo.
Continua a Parte 4: L'emergenza - Quando l'ottimizzazione diventa intelligenza
Navigazione della serie:
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.