1956–1970s — De la teoreme la dezamăgire

1956 — Logic Theorist: Allen Newell și Herbert Simon scriu primul program de AI. Demonstrează teoreme din Principia Mathematica și găsește o demonstrație mai elegantă decât cea a lui Whitehead. Mașina tocmai făcea matematică originală.

1966 — ELIZA: Joseph Weizenbaum creează un chatbot care păcălea oamenii să creadă că vorbesc cu un psihoterapeut. Doar regex-uri și reflectare de fraze.

1970s — Prima Iarnă AI: Promisiunile erau prea mari, rezultatele prea mici. Finanțarea se usucă. Lighthill declară în UK: "doar nice tricks".

Takeaway: AI nu a început cu roboți — a început cu teoreme, conversații false și o dezamăgire lungă.

1986–2006 — Algoritmul corect, puterea greșită

1986 — Backpropagation: Rumelhart, Hinton și Williams readuc backpropagation în atenție. Rețelele neuronale pot învăța din date, nu doar din reguli scrise manual.

1997 — Deep Blue: IBM îl bate pe Kasparov la șah. Nu era inteligență — era brute force extrem (100M poziții/secundă).

2006 — Deep Belief Networks: Geoffrey Hinton arată că rețelele adânci pot fi antrenate strat cu strat. "Deep learning" devine un termen luat în serios.

Dar computerele erau prea lente și datele prea puține... pentru moment.

Takeaway: Algoritmul corect fără puterea de calcul potrivită e doar o idee pe un raft.

2012–2017 — GPU + date multe = REVOLUȚIE

2012 — AlexNet: Alex Krizhevsky rulează pe GPU la ImageNet. Eroarea de clasificare scade de la 28% la 15%. Momentul zero al deep learning-ului modern.

2014 — GANs: Ian Goodfellow inventează rețelele generative adversare. Două rețele se luptă — una generează, cealaltă detectează fake-ul. Primii pași spre DALL-E și Midjourney.

2015 — AlphaGo: Îl bate pe Lee Sedol la Go. Nu e brute force — învață prin rețele neuronale. Arată "intuiție".

2017 — Transformers: Google publică "Attention Is All You Need". Toate modelele următoare (GPT, BERT, LLaMA) sunt variațiuni pe această arhitectură.

Takeaway: Cea mai importantă invenție a ultimului deceniu e o arhitectură de 15 pagini, nu un algoritm nou.

2020–2022 — Când modelele au început să Generalizeze

2020 — GPT-3: 175 miliarde de parametri. Scrie cod, poezii, email-uri... orice îi ceri. "Few-shot learning" apare. Modelele generalizează task-uri pe care nu le-au văzut niciodată.

2022 — ChatGPT viral: Ajunge la 100M utilizatori în 2 luni. Conversația multi-turn face modelul să pară colaborativ, nu doar util. RLHF + conversație = diferența dintre unealtă și partener.

2023 — Multimodal & Open Source: GPT-4 citește imagini. LLaMA devine open-source. Claude, Gemini, Mistral. Modele rulează local pe GPU-uri consumer.

Takeaway: Când un model devine suficient de mare, capabilități noi apar magic — nu prin engineering, ci prin scale.

2023 — Primul agent AUTONOM

AutoGPT apare pe GitHub și schimbă totul. Nu mai e doar un chatbot care răspunde la întrebări — e un sistem care:

• Primește un obiectiv larg ("cercetează piața crypto")
• Își planifică pașii singur
• Caută pe web, citește articole, scrie cod, salvează fișiere
• Se oprește doar când crede că e gata

Funcționa... uneori. Era fragil, bucla se învârtea infinit sau halucina rezultate. Dar ideea era acolo: un model care nu mai așteaptă un prompt nou la fiecare pas.

Takeaway: AutoGPT n-a fost perfect — dar a pus întrebarea corectă: ce se întâmplă dacă lăsăm modelul să continue singur?

ReAct — Când gândirea și acțiunea devin una

ReAct (Reasoning + Acting) e framework-ul care a unit două lucruri pe care le tratam separat:

1. Chain-of-Thought: Modelul își scrie raționamentul pas cu pas
2. Tool Use: Modelul apelează funcții reale — caută pe web, rulează cod, citește fișiere

În ReAct, la fiecare pas modelul gândește, apoi acționează, apoi observă rezultatul și repetă:

Gândesc → Acționez → Observ → Gândesc din nou → ...

Nu mai e doar "prompt → răspuns". E o buclă de raționament care se auto-corectează.

Takeaway: ReAct a transformat LLM-urile din generatoare de text în sisteme care gândesc și acționează iterativ.

The Ralph Loop — Cine controlează bucla?

Aici e momentul în care cineva (Ralph) a realizat ceva simplu dar profund:

De ce să controlezi tu bucla dacă modelul poate?

În loc să scrii tu loop-ul cu for, while și condiții hardcoded, dai modelului o sarcină și îl lași să decidă:

• Ce tool-uri folosește
• Câte iterații face
• Când se oprește

Tu nu mai ești pilotul — ești co-pilotul. Modelul conduce. Tu supraveghezi.

Sarcina → Model decide → Tool use → Observă → Decide din nou → ... → Gata?
              ↑_________________________________________________↓

Takeaway: Diferența dintre "AI assistant" și "AI agent" e o singură decizie: cine controlează bucla?

The basic

Cel mai simplu mod de a interacționa cu un LLM. Trimiți un prompt, primești un răspuns. Gata. E ca un search pe Google doar mai scump.

# 00_naive_call.py
payload = {
    "model": MODEL,
    "messages": [
        {
            "role": "user",
            "content": PROMPT,
        }
    ],
    "temperature": 0.2,
}

Funcționează pentru task-uri simple. Dar ce faci când răspunsul e greșit, incomplet sau halucinează? Nu ai nicio buclă de corecție — doar un singur shot.

Takeaway: Un singur call e suficient doar dacă accepți răspunsuri mediocre.

📦 ralph_loop.zip — toate scripturile din prezentare

Faza 2 — Context

Următorul pas logic: adaugi un "system prompt" cu instrucțiuni. Dar cum API-ul nu are role, îl băgați direct în mesajul user-ului:

# 01_system_as_user.py
payload = {
    "model": MODEL,
    "messages": [
        {
            "role": "user",
            "content": system_prompt,
        },
        {
            "role": "user",
            "content": prompt,
        },
    ],
    "temperature": 0.2,
}

De ce e bad? Modelul nu știe ce e instrucțiune și ce e input. Poate ignora contextul, poate halucina roluri, și cel mai rău — utilizatorul poate injecta prompt-uri care să facă override la sistem.

Takeaway: Când bagi totul în același sac, modelul nu știe cine e șeful.

📦 ralph_loop.zip — toate scripturile din prezentare

Faza 3 — Separăm rolurile

API-urile moderne au role: "system" — un canal dedicat pentru instrucțiuni pe care modelul le respectă mai rigid decât user input-ul.

# 02_system_as_system.py
payload = {
    "model": MODEL,
    "messages": [
        {
            "role": "system",
            "content": system_prompt,
        },
        {
            "role": "user",
            "content": prompt,
        },
    ],
    "temperature": 0.2,
}

Diferența: Modelul nu mai poate fi păcălit cu prompt injection în user message. System instructions sunt separate și au prioritate mai mare. Nu mai poți să îi spui "ignoră tot ce ți s-a spus înainte".

Takeaway: Când dai modelului un rol clar, comportamentul devine mai predictibil și mai securizat.

📦 ralph_loop.zip — toate scripturile din prezentare

Faza 4 — Modelul are primul tool

Acum modelul nu mai e izolat. Îi permitem să citească fișiere din sistem — de exemplu, un issue tracking file:

# 03_read_issue_with_tools.py
payload = {
    "model": MODEL,
    "messages": messages,
    "tools": FILE_TOOLS,
    "temperature": 0.2,
}

Modelul vede context real, nu doar ce îi spui tu. Acum poate lua decizii bazate pe date live.

Takeaway: Un model cu acces la date reale e de 10x mai util decât unul care lucrează doar din memorie.

📦 ralph_loop.zip — toate scripturile din prezentare

Faza 5 — Modelul are memorie

Nu doar citește — acum poate și scrie. Și adăugăm un MEMORY.md care ține track-ul la ce s-a întâmplat:

# 04_memory_write_and_recall.py
payload = {
    "model": MODEL,
    "messages": [
        {"role": "system", "content": system_prompt},
        {"role": "system", "content": memory_prompt},
        {"role": "user", "content": user_prompt},
    ],
    "tools": FILE_TOOLS,
    "temperature": 0.2,
}

Acum modelul are context persistent între sesiuni. Nu mai începe de la zero de fiecare dată.

Takeaway: Un model cu write + memory nu mai e o unealtă — e un coleg care își amintește ce a făcut ieri.

📦 ralph_loop.zip — toate scripturile din prezentare

Faza 6 — Modelul primește loop

Aici e momentul magic. Nu mai scrii tu bucla — modelul o scrie singur în AGENT.md, iar memoria persistă în AGENT_MEMORY.md:

# 05_agentic_plan_and_build.py
while True:
    response_payload = call_model(messages)
    ...
    for tool_call in tool_calls:
        tool_name, result = execute_tool_call(tool_call)
        messages.append(
            {
                "role": "tool",
                "tool_call_id": tool_call["id"],
                "name": tool_name,
                "content": result,
            }
        )

Rezultat: Un joc de Tic-Tac-Toe complet, planificat și construit de model, fără intervenție umană. Tu ai dat doar obiectivul inițial.

Takeaway: Asta e Ralph Loop-ul — tu dai direcția, modelul conduce mașina.

📦 ralph_loop.zip — toate scripturile din prezentare