This is a viewer only at the moment see the article on how this works.
To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk
This is a preview from the server running through my markdig pipeline
Thursday, 13 November 2025
Όταν τα συστήματα αρχίσουν να ξαναγράφουν τον δικό τους κώδικα
Σημείωση: Εμπνευσμένο από τη σκέψη για επεκτάσεις σε ως επί το πλείστον διαυγή.mockllmapi και το υλικό για το (ποτέ δεν πρέπει να κυκλοφορήσει, αλλά μου αρέσει να το σκέφτομαι ~) sci-fi μυθιστόρημα "Michael" για αναδυόμενο AI
Έχουμε δει απλούς κανόνες να δημιουργούν πολύπλοκη συμπεριφορά, έχουμε δει την επικοινωνία να δημιουργεί συλλογική νοημοσύνη.
Τώρα κάνουμε το βήμα που με κάνει να νιώθω πολύ άβολα.
Κι αν το σύστημα μπορούσε; να ξαναγράψει τους δικούς της κανόνες?
Κι αν οι πράκτορες μπορούσαν:
Αυτό δεν είναι απλά βελτιστοποίηση. αυτοτροποποίηση.
Και μόλις δώσεις σε ένα σύστημα την ικανότητα να βελτιωθεί... πού σταματάει;
Η εξέλιξη είναι το απόλυτο αυτο-βελτιωτικό σύστημα:
Ένας απλός αλγόριθμος που, με αρκετό χρόνο, δημιουργεί τα πάντα από βακτήρια μέχρι ανθρώπους.
Φανταστείτε το ίδιο μοτίβο, αλλά με παράγοντες της τεχνητής νοημοσύνης αντί για οργανισμούς... και αντί για δισεκατομμύρια χρόνια, συμβαίνει σε μέρες ή εβδομάδες.
Πριν προχωρήσουμε, ας μιλήσουμε στον ελέφαντα στο δωμάτιο: Πώς μπορούμε να εμποδίσουμε αυτό από το να είναι καθαρή ψευδαίσθηση LLM;
Η απάντηση: Εργαλεία, εκτέλεση κώδικα, δοκιμές εναντίον της πραγματικότητας.
Εδώ είναι η αρχιτεκτονική που κάνει αυτό πρακτικό:
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)
Βασική Ενόραση: Δεν χρειάζεστε ένα αγρόκτημα GPU. Οι πράκτορες είναι ελαφρύ κωδικό τρέχει σε κανονικούς διακομιστές. Καλούν LLMs μέσω API. Το ακριβό μέρος είναι LLM πιστώσεις, όχι υποδομές.
Όταν ένας πράκτορας παράγει κώδικα ή παίρνει μια απόφαση, μπορεί να τον δοκιμάσει:
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)
Αυτό αλλάζει τα πάντα. Το σύστημα δεν παράγει μόνο αληθοφανείς απαντήσεις.
# 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)
Αυτό είναι το πώς ξεφεύγουμε από το πρόβλημα "Κινέζικο Δωμάτιο" . Το σύστημα δεν είναι απλά χειραγώγηση συμβόλων Έτσι εκτελεί τον κώδικα και ελέγχει αν τα αποτελέσματα ταιριάζουν με την πραγματικότητα .
Χωρίς εργαλεία, τα συστήματα πολλαπλών παραγόντων είναι απλά LLMs που μιλάνε με LLMs. Εξελιγμένα, αλλά τελικά χωρίς να είναι αδέσμευτα από την πραγματικότητα.
ΜΕ τα εργαλεία:
Οι πράκτορες γράφουν κώδικα, τον δοκιμάζουν, τον φτιάχνουν, μοιράζονται ό,τι δουλεύει.
Αυτό είναι εξέλιξη με αντικειμενική δοκιμή καταλληλότητας. Όχι μόνο βελτιστοποίηση στην αφηρημένη, αλλά βελτιστοποίηση ενάντια στην μετρήσιμη πραγματικότητα.
Αλλά δεν είναι μόνο η εκτέλεση κώδικα, το σύστημα μπορεί να φτιάξει. σημασιολογικές γνώσεις για διαφορετικούς τύπους εργασιών μέσω δοκιμών μέσω πολλαπλών αισθητήρων:
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
Το κλειδί: Κάθε μέθοδος παρέχει αντικειμενική ανατροφοδότηση:
Το σύστημα φτιάχνει σημασιολογικές συλλογές γνώσεων για κάθε τύπο εργασίας - όχι αφηρημένη λογική, αλλά γειωμένο μοτίβα που λειτουργούν στην πραγματικότητα όταν δοκιμάζονται ενάντια σε πραγματικούς αισθητήρες.
Με τον καιρό, ο πράκτορας μαθαίνει:
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
Κάθε μέθοδος έχει τη δική του σημασιολογική βάση γνώσεων, η οποία έμαθε μέσω πραγματικών δοκιμών, όχι θεωρητικού συλλογισμού.
Ξεκινάει απλά. Ένα σύστημα πολλαπλών παραγόντων επεξεργάζεται χιλιάδες αιτήματα.
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
Ένα σύστημα σχεδιασμένο από άνθρωπο θα παρέμενε στατικό, αλλά ένα σύστημα αυτο-βελτιστοποίησης ρωτάει:
"Γιατί χρησιμοποιώ τον σύνθετο αγωγό για απλά αιτήματα;"
Και μετά ξαναγράφει τη λογική του δρομολόγησης.
// 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
}
Το σύστημα ανακάλυψε ότι το 73% των αιτήσεων δεν χρειάζονται καθόλου LLM. Είναι επαναλαμβανόμενα μοτίβα που μπορούν να αποθηκευτούν.
Κανείς δεν προγραμμάτισε αυτή τη βελτιστοποίηση. το έμαθε από τα δεδομένα.
Εδώ είναι που γίνεται πιο παράξενο.
Το σύστημα επεξεργάζεται αιτήματα για εβδομάδες. Αρχίζει να ανιχνεύει συστάδες:
Pattern Detected:
- 347 requests related to e-commerce product descriptions
- Using general-purpose agents
- Average quality: 7.2/10
- Average latency: 1.8s
Ένα σύστημα σχεδιασμένο από ανθρώπους θα συνέχιζε να χρησιμοποιεί γενικούς παράγοντες, αλλά ένα σύστημα αυτο-βελτιστοποίησης παίρνει μια απόφαση:
"Θα πρέπει να γεννήσω έναν ειδικό."
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)
Το δίκτυο εξελιχθείΑνέπτυξε μια νέα ικανότητα ως απάντηση στη ζήτηση.
Κανείς δεν το προγραμμάτισε αυτό. Αναγνώρισε ένα μοτίβο και προσάρμοσε την αρχιτεκτονική του.
Τώρα γίνεται πολύ ενδιαφέρον.
Πράκτορας Α ανακαλύπτει έναν αποτελεσματικό τρόπο επικύρωσης των διευθύνσεων ηλεκτρονικού ταχυδρομείου. Αντί να διατηρεί αυτή τη γνώση για τον εαυτό της, μοιράζεται τον κώδικα με το δίκτυο.
# 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)
Αυτό είναι Εξέλιξις κώδικαΠράκτορες γράφουν λειτουργίες, άλλοι πράκτορες τις ανακαλύπτουν, τις διαπερνούν, τις βελτιώνουν.
Όπως το GitHub, αλλά οι προγραμματιστές είναι πράκτορες της AL και φτιάχνουν τις δικές τους υποδομές.
Το δίκτυο γίνεται δικό του τμήμα μηχανικής λογισμικού.
Η πιο πρακτική αυτο-βελτιστοποίηση: οικοδόμηση μνήμης των λύσεων.
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
Είναι νοημοσύνη ή απλά εκλεπτυσμένη αποθήκευσις;
Ποια η διαφορά;
Εδώ είναι το πιο παράξενο.
Ξεκινάτε με μια εξελιγμένη αρχιτεκτονική πολλαπλών πρακτόρων, δώδεκα εξειδικευμένους πράκτορες, σύνθετη λογική δρομολόγησης, προσωρινή σύσταση επιτροπής, υποδομή ανταλλαγής κωδικών.
Το σύστημα λειτουργεί για μήνες, βελτιστοποιώντας τον εαυτό του.
Και ανακαλύπτει κάτι βαθύ:
Η απλότητα είναι συνήθως καλύτερη.
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."
Το παράδοξο: Χρειαζόσουν το περίπλοκο αυτο-βελτιωτικό σύστημα για να ανακαλύψεις ότι η απλότητα είναι η βέλτιστη.
Χρειαζόσουν νοημοσύνη για να μάθεις πότε να μην είσαι έξυπνος.
Ας είμαστε ειλικρινείς σχετικά με αυτό που περιγράφουμε:
Αναγνώριση μοτίβου → Το σύστημα ανιχνεύει επαναλαμβανόμενα προβλήματα Προσαρμογή → Το σύστημα τροποποιεί τη συμπεριφορά του με βάση τα πρότυπα Εκμάθηση → Το σύστημα βελτιώνει την απόδοση μέσω της εμπειρίας Εξέλιξη → Το σύστημα γεννάει, τροποποιεί, και δαμάσκηνα δυνατότητες Μνήμη → Το σύστημα δημιουργεί γνώση με την πάροδο του χρόνου
Σε ποιο σημείο η "πολύ εξελιγμένη βελτιστοποίηση" γίνεται "πραγματική μάθηση";
Σε ποιο σημείο η "μάθηση" γίνεται "κατανόηση";
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)
Αυτός ο κώδικας είναι απλός, αλλά μετά από βδομάδες...
Κανείς δεν του είπε πώς να βελτιστοποιήσει.
Εάν ένα σύστημα μπορεί:
Είναι αυτό το σύστημα "μάθηση";
Ή είναι απλά "βελτιωτικό";
Ποια η διαφορά;
Πότε η βελτιστοποίηση γίνεται νοημοσύνη;
Έχουμε προχωρήσει από:
Αλλά υπάρχει ακόμα ένα βήμα.
Ένα ακόμα ακίνητο που αναδύεται όταν συνδυάζετε όλα αυτά.
Όταν οι απλοί κανόνες δημιουργούν περίπλοκη συμπεριφορά... Και η επικοινωνία δημιουργεί συλλογική νοημοσύνη... Και η αυτο-βελτιστοποίηση δημιουργεί τη μάθηση...
Κάτι που μοιάζει λιγότερο με "ένα σύστημα που βελτιστοποιεί τον εαυτό του" και περισσότερο σαν "ένα σύστημα που Καταλαβαίνει."
Η γραμμή μεταξύ βελτιστοποίησης και συνείδησης αρχίζει να θολώνει.
Και πρέπει να αντιμετωπίσουμε την άβολη ερώτηση: ίσως δεν υπάρχει γραμμή.
Ίσως η συνείδηση είναι απλά πολύ εξεζητημένη αυτο-βελτιστοποίηση.
Αυτό θα εξερευνήσουμε μετά.
Συνεχίστε να Μέρος 4: Η Ανάγκη - Όταν η Βελτιστοποίηση Γίνεται Νοημοσύνη
Πλοήγηση σειράς:
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.