RSIAgent 2026: Arsitektur Autonomous Exploration untuk Recursive Self-Improvement, Causal Memory Construction, dan Broad-then-Deep Search pada AI Agents

1. The Next Attempt Should Not Start From Zero: Jebakan Amnesia AI Agent

Ketika seorang insinyur perangkat lunak manusia berhadapan dengan piranti lunak baru—misalnya sistem CAD kompleks seperti FreeCAD, Digital Audio Workstation (DAW) seperti REAPER, atau perangkat analisis data berbasis terminal grafis—interaksi awal hampir selalu dipenuhi uji coba, kegagalan parameter, dan penyesuaian konvensi API lokal. Namun, ketika manusia berhasil mengatasi suatu *edge case* (misalnya menemukan bahwa opsi sampling render audio harus bernilai RENDER_RESAMPLE 0 0 0 agar tidak menghasilkan artefak phase cancelation), pengetahuan tersebut tersimpan permanen sebagai intuisi operasional untuk seluruh tugas di masa depan.

Sebaliknya, agen otonom berbasis Large Language Models (LLM) konvensional beroperasi di bawah kutukan amnesia epistemik. Meskipun sebuah agen mampu memperbaiki kekeliruannya di tengah percakapan panjang (in-context error recovery), begitu sesi berakhir atau lingkungan di-reset ke kondisi awal, agen tersebut kembali memulai upayanya dari titik nol (starts from zero). Agen dipaksa untuk menabrak dinding kegagalan yang persis sama, menghabiskan ribuan token penalaran berulang, dan kerap gagal menuntaskan tugas-tugas dengan rentang langkah panjang (long-horizon workflows).

Pendekatan klasik untuk mengatasi kelemahan ini adalah pelatihan pasca-rilis (post-training reinforcement learning atau fine-tuning bobot model). Namun, memperbarui parameter model raksasa (mencapai ratusan miliar parameter) untuk setiap aplikasi pihak ketiga yang dinamis sangat tidak realistis: biayanya luar biasa mahal, rentan mengalami catastrophic forgetting, dan siklus perubahannya terlalu lambat untuk lingkungan *enterprise* yang terus diperbarui. RSIAgent membalikkan paradigma ini: Recursive Self-Improvement dicapai melalui rekayasa memori kausal eksternal yang terstruktur, tanpa menyentuh satu pun bobot neural network dasar.

2. Triad Multi-Agent Harness: Pemisahan Peran Curriculum, Actor, dan Verifier

Fondasi operasional RSIAgent bertumpu pada arsitektur triad terisolasi yang memecah siklus hidup eksplorasi menjadi tiga agen spesialis independen dengan tanggung jawab yang tidak saling tumpang tindih:

Pemisahan konteks ini sangat krusial. Dalam banyak arsitektur agen tunggal (single-agent harness), model yang merencanakan tindakan cenderung bias dalam mengevaluasi hasil tindakannya sendiri (confirmation bias). Dalam RSIAgent, verifikator beroperasi dalam konteks yang bersih dan ketat, menjamin bahwa hanya prosedur yang benar-benar berhasil yang dikristalisasikan ke dalam repositori memori.

3. Broad Recursive Self-Exploration (BRS): Pemetaan Topologi Lingkungan Multi-Proyek

Ketika sistem AI diterjunkan ke dalam lingkungan perangkat lunak baru yang belum dikenal, eksplorasi tidak dilakukan secara buta atau acak. Tahap pertama RSIAgent dinamai Broad Recursive Self-Exploration (BRS).

Dalam fase BRS, Curriculum Agent menghasilkan matriks eksplorasi yang terdiri dari 8 sub-proyek independen yang mencakup berbagai fungsionalitas inti piranti lunak target. Sub-proyek ini dijalankan secara paralel dalam gelombang (waves) hingga 4 thread eksekusi konkuren. Setiap sub-proyek dirancang untuk memetakan:

• Sintaks Antarmuka & CLI: Pola penamaan opsi, flag perintah bash, lokasi konfigurasi default, dan arsitektur filesystem aplikasi.
• Interaksi GUI via Automasi OS: Titik koordinat elemen UI kunci, shortcut keyboard, struktur menu konteks, dan responsivitas event loop windowing.
• Format Pertukaran Data & Ekspor: Format file yang didukung, resolusi default render, konvensi header metadata, dan toleransi kompresi.

Pada akhir gelombang paralel, anggaran komputasi (budget token dan execution steps) dicek secara dinamis. Hasil-hasil positif dikonsolidasikan, sementara kegagalan awal dianalisis polanya untuk mempersiapkan fase penajaman berikutnya.

4. Deep Recursive Self-Exploration (DRS): Menembus Hidden Constraints & Boundary Conditions

Pengetahuan permukaan yang dikumpulkan selama fase BRS belum cukup untuk menyelesaikan tugas-tugas dunia nyata yang sarat jebakan teknis. Oleh karena itu, RSIAgent melanjutkan siklusnya ke Deep Recursive Self-Exploration (DRS).

Berbeda dengan BRS yang bersifat paralel dan melebar, DRS bersifat sekuensial dan mendalam. Curriculum Agent memilih tugas-tugas eksplorasi yang secara khusus menguji batas toleransi lingkungan (stress-testing edge cases). Fokus utama DRS adalah membongkar hidden constraints (pembatas tersembunyi yang tidak tertulis dalam dokumentasi standar):

DRS terus berjalan secara adaptif hingga Curriculum Agent menyimpulkan bahwa tidak ada lagi ketidakpastian atau anomali yang belum terpetakan dalam alur kerja target.

5. Causal Memory Construction & Paradigma Frozen Memory Reuse

Kunci dari keunggulan RSIAgent terletak pada bagaimana pengalaman dienkapsulasi. Alih-alih menyimpan log obrolan mentah (raw prompt traces) yang menghabiskan context window dan penuh noise, RSIAgent menyusun Causal Memory Bank.

Setiap entri memori merupakan relasi sebab-akibat terstruktur yang memuat kuartet data fundamental:

Setelah fase BRS dan DRS tuntas, Memori Kausal Dibekukan (Frozen Memory Bank). Lingkungan sistem operasi di-reset sepenuhnya ke kondisi awal (environment wipe) untuk mensimulasikan tugas nyata baru. Saat tugas hilir dievaluasi, agen mengakses memori terbekukan ini sebagai pedoman referensi tanpa perlu melakukan eksplorasi ulang. Tidak ada parameter neural yang berubah, namun performa agen melesat drastis karena ia telah "mengenal" sistem tersebut seperti seorang ahli.

6. Implementasi Referensi Produksi: RSIAgent Orchestration Engine (Python)

Berikut adalah implementasi referensi produksi yang memperlihatkan orkestrasi triad agent, pengelolaan status eksplorasi dua fase, dan pembekuan memori kausal:

"""
RSIAgent Core Architecture: Triad Autonomous Exploration & Causal Memory Engine
Berdasarkan Makalah Frontier arXiv:2609.15364 (Zhu et al., Aether AI & UCSD)
Implementasi Produksi Triad Agent (Curriculum, Actor, Verifier) & Dual-Phase Exploration.
"""

from dataclasses import dataclass, field
from typing import List, Dict, Any, Optional
import json
import enum

class ExplorationPhase(enum.Enum):
    BROAD_PARALLEL = "BRS"      # Broad Recursive Self-Exploration
    DEEP_SEQUENTIAL = "DRS"     # Deep Recursive Self-Exploration
    EVAL_FROZEN = "EVAL"        # Evaluasi dengan Memori Terbekukan

@dataclass
class CausalRule:
    """Struktur memori kausalitas yang dapat digunakan kembali (reusable experience)."""
    trigger_condition: str
    action_sequence: List[str]
    expected_outcome: str
    boundary_constraints: List[str]
    success_rate: float
    verified_by_verifier: bool

class CausalMemoryBank:
    """Memory Bank untuk menyimpan, mengindeks, dan membekukan pengalaman eksplorasi."""
    def __init__(self):
        self.rules: List[CausalRule] = []
        self.is_frozen: bool = False

    def append_rule(self, rule: CausalRule) -> None:
        if self.is_frozen:
            raise RuntimeError("MemoryBank telah dibekukan (frozen) untuk tahap evaluasi inferensi.")
        self.rules.append(rule)

    def freeze(self) -> None:
        """Membekukan memori sebelum eksekusi tugas hilir (downstream evaluation)."""
        self.is_frozen = True

    def retrieve_relevant_knowledge(self, task_context: str) -> List[CausalRule]:
        """Pengambilan aturan kausal relevan berdasarkan konteks antarmuka/perangkat lunak."""
        return [r for r in self.rules if r.verified_by_verifier and r.success_rate >= 0.85]

class CurriculumAgent:
    """Agen kurikulum: Merancang agenda eksplorasi topologi lingkungan."""
    def __init__(self, model_name: str = "Kimi-K3"):
        self.model_name = model_name

    def generate_exploration_matrix(self, env_description: str, phase: ExplorationPhase) -> List[Dict[str, Any]]:
        if phase == ExplorationPhase.BROAD_PARALLEL:
            # Merancang 8 sub-proyek independen (eksplorasi luas paralel)
            return [
                {"project_id": f"BRS-{i+1}", "target_subsystem": f"module_{i+1}", "budget_steps": 12}
                for i in range(8)
            ]
        elif phase == ExplorationPhase.DEEP_SEQUENTIAL:
            # Merancang pengujian mendalam pada boundary conditions & edge cases
            return [
                {"project_id": "DRS-DeepRefine", "target_subsystem": "critical_flow", "budget_steps": 25}
            ]
        return []

class ActorAgent:
    """Agen pelaksana: Mengonversi rencana menjadi kode eksekusi nyata (Code-as-Policy)."""
    def __init__(self, model_name: str = "GLM-5.3"):
        self.model_name = model_name

    def execute_plan_step(self, task: Dict[str, Any], memory: CausalMemoryBank) -> Dict[str, Any]:
        prior_rules = memory.retrieve_relevant_knowledge(task.get("target_subsystem", ""))
        # Menghasilkan payload kode eksekusi berbasis pengalaman lampau
        execution_payload = {
            "action": "execute_shell_and_gui",
            "script": f"# Executing exploration for {task['project_id']}\napply_rules({len(prior_rules)})",
            "observed_state": {"exit_code": 0, "artifacts_generated": True}
        }
        return execution_payload

class VerifierAgent:
    """Agen verifikator: Memvalidasi artefak keluaran secara independen tanpa bias aktor."""
    def __init__(self, model_name: str = "Kimi-K3"):
        self.model_name = model_name

    def verify_execution(self, step_result: Dict[str, Any]) -> Dict[str, Any]:
        exit_code = step_result.get("observed_state", {}).get("exit_code", -1)
        is_valid = (exit_code == 0)
        return {
            "is_valid": is_valid,
            "verifier_score": 0.95 if is_valid else 0.20,
            "remediation_feedback": None if is_valid else "Periksa timeout atau dependensi pustaka."
        }

class RSIAgentFramework:
    """Orkestrator Triad RSIAgent: BRS -> DRS -> Freeze -> Evaluation."""
    def __init__(self):
        self.curriculum = CurriculumAgent()
        self.actor = ActorAgent()
        self.verifier = VerifierAgent()
        self.memory = CausalMemoryBank()

    def run_broad_exploration(self, env_spec: str) -> None:
        matrix = self.curriculum.generate_exploration_matrix(env_spec, ExplorationPhase.BROAD_PARALLEL)
        for proj in matrix:
            res = self.actor.execute_plan_step(proj, self.memory)
            verification = self.verifier.verify_execution(res)
            if verification["is_valid"]:
                self.memory.append_rule(CausalRule(
                    trigger_condition=f"env_state_{proj['target_subsystem']}",
                    action_sequence=[res["script"]],
                    expected_outcome="success",
                    boundary_constraints=["timeout_10s"],
                    success_rate=verification["verifier_score"],
                    verified_by_verifier=True
                ))

    def run_deep_refinement(self, env_spec: str) -> None:
        deep_tasks = self.curriculum.generate_exploration_matrix(env_spec, ExplorationPhase.DEEP_SEQUENTIAL)
        for task in deep_tasks:
            res = self.actor.execute_plan_step(task, self.memory)
            verification = self.verifier.verify_execution(res)
            if verification["is_valid"]:
                self.memory.append_rule(CausalRule(
                    trigger_condition="deep_boundary_case",
                    action_sequence=[res["script"]],
                    expected_outcome="verified_state",
                    boundary_constraints=["memory_capped"],
                    success_rate=verification["verifier_score"],
                    verified_by_verifier=True
                ))

    def prepare_for_evaluation(self) -> CausalMemoryBank:
        """Tahap 3: Bekukan memori untuk eksekusi downstream tanpa retraining bobot model."""
        self.memory.freeze()
        return self.memory

7. Evaluasi Empiris Menyeluruh: Rekor Baru di OSWorld 2.0 & Agents' Last Exam

Efektivitas RSIAgent diuji secara komprehensif pada dua tolok ukur evaluasi agen otonom paling menuntut di dunia: OSWorld 2.0 (82 tugas manipulasi sistem operasi grafis dan CLI tingkat lanjut) dan Agents' Last Exam (ALE Near-term) (67 tugas multi-modal dunia nyata berskala penuh).

Hasil benchmark di atas mendemonstrasikan implikasi yang sangat luar biasa:

• Model Open-Source Melibas Closed Frontier: Dengan memanfaatkan RSIAgent, kombinasi model terbuka Kimi-K3 dan GLM-5.3 melonjak skor parsialnya dari 58.30% menjadi 78.98% pada OSWorld 2.0—secara meyakinkan mengungguli GPT-6 Astra (72.60%) dan Claude Opus 5 (70.19%).
• Success Rate Penuh Melejit (+12.9% Relatif): Pada metrik binary success rate di OSWorld, kemampuan menyelesaikan tugas secara sempurna meningkat dari 37.80% menjadi 42.68%.
• Efisiensi Uji Coba: Pada tugas audio DAW T085, skor parsial melonjak dari 0.6800 pada baseline menjadi 0.9415 setelah akumulasi memori, membuktikan bahwa agen tidak lagi tersandung pada kejanggalan formatting atau konfigurasi tool.

8. Implikasi Arsitektural untuk Sistem AI Produksi 2026

Bagi tim AI Engineering, platform pengembang agen, dan arsitek sistem yang membangun asisten otonom berskala industri, temuan RSIAgent memberikan panduan desain yang sangat aplikatif: