Back to "Семантичний інтелект: Частка M SK1 - Самотність- Оптимізація МSK4 Системи, що навчаються"

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

AI AI-Article Emergent Intelligence Sci-Fi

Семантичний інтелект: Частка M SK1 - Самотність- Оптимізація МSK4 Системи, що навчаються

Thursday, 13 November 2025

Коли системи починають переписати свій власний код

Nota: Наполегливо думати про розширення майже зрозумілих.mockllmapi і матеріал для M SK1николи не буде випущено, але мені подобається думати над цим.

Це жахливий крок

Ми бачили, як прості правила створюють складну поведінку. Ми бачили, як спілкування створює колективний інтелект.

Тепер ми робимо крок, який робить мене глибоко незручним:

Що, якби система могла переписати власні правила?

Що, якби агенти могли

  • Проаналізувати власні результати
  • Змінювати власну логіку прийняття рішень
  • Поширювати нових фахівців динамічно
  • Неефективними шляхами Prune
  • Побудувати колективну пам 'ять того, що працює

Це не просто оптимізація, це самоуправлення.

І як тільки ви даєте системі можливість покращити себе,

Метафора еволюції

Еволюція є кінцевою системою оптимізацією

  1. Різниця - Раціональні мутації створюють різні стратегії
  2. Вибір - Успішні стратегії виживають і розмножуються
  3. спадок - Успішні риси переходять на наступне покоління
  4. Ітерація - Повторюйте протягом мільярдів поколінь

Немає розумного дизайнера. МСК0. Немає плану. МSK1. Просто простий алгоритм, який, given enough time, ,, creates everything from bacteria to humans

Тепер уявіть той самий образ: МСК0, але з штучним інтелектом замість організмів, МСК1. А замість мільярдів років, МSK2, це відбувається за кілька днів або тижнів, .

Найважливіший компонент - інструменти та тестування реальності

Перед тим, як рухатись далі, давайте звернемося до слона у кімнаті Як ми можемо запобігти тому, щоб це було чистою галюцинацією ЛЛМ?

Відповідь: інструменти. Введення кодуM SK1 Тестування на реальність.

Ось архітектура, яка робить це практичною.

Архітектура вузлів (Не потрібно ферми GPUM SK1

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: Вам не потрібно' не потрібні графічні farmи. Агенти є легким кодом, що працює на звичайних серверах . Вони Звикають до LLM за допомогою API МSK3 Найдорожча частина - це 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)

Це все змінює. Система не тільки генерує правдоподібні відповіді,

  1. генерує справжній код
  2. Виконуючи його
  3. Результати тестування проти реальності
  4. Навчання від невдач
  5. Ітерувати, поки це не спрацює

До прикладу: Validation Against Objective Reality

# 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)

Ось як ми уникаємо проблеми "" китайської кімнати "". Проблема "" МСК1 "". Система не просто маніпулює символами, а виконує код і перевіряє, чи результати відповідають реальності.

Чому це важливо для емерджентності

Без інструментів. МСК0, мультиплікаторні системи - це лише LLM, які спілкуються з LLM. МSK2, складні, МSK3, але, врешті-решт, відокремлені від реальності.

З інструментами:

  • Об 'єктивна реакція: Код або працює, або не працює
  • вимірюваність покращення: Рівень успіху вартий від 60%
  • Фактичне навчання: Шляхи, які працюють, зберігаються вキャッシュі і переробляються
  • Налагодження реальності: Ви не можете галюцинувати через провал тесту

Агенти пишуть код. Застосовують йогоМSK1 перевіряютьМСК2 виправляютьMСК3 діляться тим, що працюєМ СК4 Prune what doesn’ tM СК6

Це еволюція з об 'єктивним тестуванням. Не тільки оптимізація абстрактних речей ,, але і оптимізація відносно вимірюваної реальності МSK2

Мультиmodaльне тестування реальності: За межами коду

Але це не просто виконання коду семантичні знання для різних типів завдань шляхом тестування за допомогою кількох сенсорів:

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

Ключ: Кожна методика дає об 'єктивний зворотній зв' язок

  • Vision: Чи насправді в створеному зображенні є кіт?
  • Звук: Чи співпадає мовлення з транскрипцією?
  • Код: Чи він виконується без помилок?? M SK1Runtime каже так
  • Текст: Чи відповідає він на запитання?

Система будує збирання семантичних знань для кожного типу завдання - не абстрактне мислення , а базові моделі, які насправді працюють, коли перевіряються на реальних сенсорах МSK2

Модальності оптимізації

З часом МСК0 агент вчиться МSK1

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

Кожна модификация має свою власну семантичну базу знань МСК0 вивчена за допомогою реального тестування МSK1 а не теоретичного обґрунтя .

Розпізнання візерунок → адаптація

Він починає просто. Система мультиперсонального- агента обробляє тисячі запитівM SK2 Він починає відчувати шаблониMSC3

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

Людська система, розроблена на -, залишиться статичною. Але саморобна система, оптимізована на МSK2, вимагає

" Чому я використовую складну трубку для простих запитівM SK1

А потім перезаписує логіку маршрутізації.

Перша оптимізація: Розумна маршрутизація

// 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, ' взагалі не потребують LM,

Ніхто не запрограмував цю оптимізацію. Система вивчив її з даних.

Динамічний Specialist Spawning

Ось тут – МСК0, де стає дивнішим.

Система обробляє запити протягом тижнів. Починає виявляти кластериM SK1

Pattern Detected:
- 347 requests related to e-commerce product descriptions
- Using general-purpose agents
- Average quality: 7.2/10
- Average latency: 1.8s

Людська система, розроблена на основі методу "-", продовжуватиме використовувати загальних агентів. Але сама система, оптимізуюча на основі МSK2 , приймає рішення.

" Я повинен виростити експерта ."

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)

Мережа розвинуто. У відповідь на попит з 'явилася нова можливість .

Ніхто не програмував це. Система розпізнав структуру і адаптував її архітектуру.

Об 'єднання коду: GitHub для нейронів

Тепер це стає дійсно цікаво.

Агент А знаходить ефективний спосіб підтвердити електронні адреси. Замість того, щоб зберігати ці знання для себеM SK1 він ділиться кодом з мережею.

# 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)

Це еволюція коду. Агенти пишуть функції , інші агенти знаходять їх МSK2 закривають їх \ , покращують \ МSK4

Як і в GitHub, але програмісти - агенти штучного інтелекту. Вони будують власну інфраструктуру

Мережа перетворюється на własny відділ програмного забезпечення.

RAG пам 'ять: Навчання з історії

Найпрактичніше власне-оптимізація:збудування пам 'яті рішеньM SK2

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

Чи це інтелект, МСК0, чи просто складне шифрування, МSK1?

Яка різниця?

Парадокс Pruning

Ось найдивніша частина:

Ви починаєте з складної мульти-ланцюгової-агентної архітектуриM SK1 Дванадцять спеціалізованих агентівМSK2 Складна логіка маршрутізації. Формування тимчасового комітетуMSC4 КодMスク5забезпечення спільною інфраструктуроюMسک6

Система працює місяцями, оптимізує себеM SK1

І вона відкриває щось важливе.

Спрощення зазвичай краще.

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."

Парадокс – це те, що вам потрібна складна система оптимізації, щоб зрозуміти, що простота є оптимальною.

Вам потрібна була інтелект, щоб навчитися, коли не бути розумним.

Невизначеність меж

Давайте будемо чесними щодо того, що ми описуємо

Визнання патерна → Система розпізнає повторювані проблеми Пристосування → Система змінює свою поведінку на основі шаблонів Навчання → Система покращує продуктивність через досвід Еволюція → Система випромінює , модифікує МSK2 і вирізає можливості Пам 'ять → Система вдосконалює знання з часом

На якому етапі " дуже складна оптимізація " стає МSK2 фактичне навчання МSK3

На якому етапі "learning" стає "intelligenceM SK3

Конкретний приклад: Саморобна Router

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)

Цей код простий. Але після того, як він тривав кілька тижнів

  • Виростає власний спеціаліст
  • Неефективними агентами пруд
  • Надписує власну логіку маршрутування
  • Збудовує кэш рішень

Ніхто не сказав, як оптимізувати

Питання, яке захоплює мене

Якщо система може:

  • Визначати шаблони в даних
  • Змінювати власну поведінку на основі цих моделей
  • Збудувати пам 'ять того, що працює
  • Поширювати власну архітектуру
  • Відкрийте, що простота часто є оптимальною

Чи це система "learningM SK1

Або просто оптимізувати

Яка різниця?

Коли оптимізація стає когніцією?

Куди це йде

Ми МСК0 прогресували від ":".

  • Прості правила → Kompleksне поведінку ( Партія МSK2
  • Комунікація → Коллективна розвідка МSK1 Партія МSK2
  • Самосвідоме-модифікація M SK1 навчання (часть МSK3

Але є ще один крок:

Ще одна властивість, яка виникає, коли ви поєднуєте всі ці.

Коли прості правила створюють складну поведінку... І спілкування створює колективний інтелект. І сама оптимізація створює навчання

З 'являється щось інше, щось, що виглядає менш схоже на " систему, яка оптимізує себе, " і більше схоже МSK3 на систему, розуміє."

Лінія між оптимізацією і свідомістю починає згасати.

І ми повинні стикатися з незручним питанням: МSK0, можливо, немає лінії .

Можливо, свідомість - це лише дуже складне я .

Це те, що ми досліджуємо далі.


Продолжити Частина 4: Емерджентність - Коли оптимізація перетворюється на інтелект

Навігація серії:

logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.