Self-Improvements in Modern Agentic Systems: A Survey
Abstract: Self-improving autonomous agents are moving from research prototypes to deployed systems. The primary goal is controllable evolution, or adaptation, from experience with minimal or even no human input. This survey frames modern self-improving agents as adaptive systems that convert experience into accumulated capability gains. We offer a system-level framework that represents a modern agent as a configuration coupling a foundation model with an operational scaffold of prompts, memory, tools, and control logic. Within this framework, self-improvement is formalized as a self-induced update operator that obtains and commits updates to model parameters or scaffold components. We organize prior work by update target and by the signals that drive change, then review applications and discuss evaluation, before closing with open problems and future directions. For convenience, we track technical updates on https://github.com/selfimproving-agent/awesome-Self-Improving-Agents.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
What this paper is about (big picture)
This paper is a survey about AI โagentsโ that can improve themselves over time with little or no human help. Think of an agent as a smart helper with:
- a brain (a large AI model, like a powerful LLM), and
- a backpack (a โscaffoldโ) full of instructions, memory, tools (like web browsers or code runners), and rules for how to act.
The paper explains how these agents learn from their experiences, organize whatโs known in the field, and offer a simple way to compare many different self-improving methods.
The questions the paper tries to answer
- What do people mean by โself-improving AI agents,โ and how do we describe them in a clear, standard way?
- What exactly gets improved when an agent improves itself: the brain, the backpack, or both?
- Where do the learning signals come from (who tells the agent what went well or badly)?
- How can we test whether an agent truly gets better over time?
- What have past researchers already tried, and what important problems are still open?
How the paper approaches the topic
The authors donโt run one big experiment. Instead, they read and organize many papers and older ideas into one framework, using easy analogies:
- The agentโs โbrainโ is a foundation model (the big AI model with parametersโits learned settings).
- The agentโs โbackpack,โ called the scaffold, includes the pieces around the brain: prompts (instructions), memory (notes the agent keeps), tools (software or APIs it can call), and control logic (the plan for how it decides what to do next).
They say agents can improve in two main ways:
- Foundation model improvement: updating the brainโs parameters. This is slower but gives long-lasting gains across many tasks.
- Scaffolding improvement: changing the backpack (prompts, memory, tools, or the full workflow) without touching the brainโs parameters. This is faster and easier to undo.
They also explain where โupdate signalsโ come fromโbasically, how the agent knows what to change:
- Intrinsic generative demonstrations: the agent creates its own practice data and uses it to learn.
- Intrinsic evaluative feedback: the agent critiques its own work (like writing and grading its own homework).
- Extrinsic exploratory experience: the agent tries things in real or simulated environments (like browsing the web or playing in a virtual world) and learns from successes and mistakes.
Finally, they cover how to evaluate improvement (scores, benchmarks, and even agents that judge other agents) and trace the history of these ideasโfrom early math and control theory to modern โGรถdel Machineโ concepts that only rewrite themselves when they can prove it will help.
What they found (and why it matters)
- A unified map of the field: Many papers use different names for similar ideas (like โself-correction,โ โself-play,โ โmeta-promptingโ). The authors show how they fit together under the brain-versus-backpack view.
- Two clear improvement paths:
- Brain updates are slower but more permanent and general.
- Backpack updates are quick, flexible, and reversible (great for rapid iteration).
- Three main learning signals: make your own data, critique your own work, or learn by doing in the world.
- Language makes self-improvement easier: modern agents use natural language for planning and self-editing, which shrinks the search space and speeds improvement.
- Evaluation is hard but crucial: the paper reviews task-specific tests (like coding or web navigation), mechanism tests (prompting, memory, tool use), and โjudgeโ agents for grading. Good tests are needed to avoid fake progress.
- Safety and reliability matter: letting an agent rewrite itself can cause drift or risky behavior. The survey highlights safeguards, verification, and careful measurement.
Why this work could be a big deal
If agents can safely teach themselves, they can:
- reduce the need for human labels and coaching,
- adapt to new tasks and tools on their own,
- carry lessons across different jobs (especially when the brain itself gets better),
- and keep getting more capable in real settings like software engineering, web browsing, science, and robotics.
But this only works well if we have the right checks: good evaluation, strong safety rules, and methods that combine both brain and backpack improvements thoughtfully.
Bottom line
This survey gives a simple, useful way to think about self-improving AI:
- Treat the agent as a brain plus a backpack.
- Improve the brain for durable skills; improve the backpack for quick wins.
- Learn from your own data, your own critiques, and your own experiences.
- Test carefully, verify safety, and build reliable feedback loops.
By organizing the fast-growing research in one place, the paper helps researchers and builders design agents that can keep learningโsafely and effectivelyโon their own.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
Below is a single, concrete list of what remains missing, uncertain, or unexplored, based on the paperโs framing and scope.
- Formal guarantees for self-induced update operators: precise definitions, convergence/stability conditions, and monotonic-improvement guarantees for both foundation-model updates and scaffold updates.
- Decision policies for โwhat to update whenโ: principled, quantitative criteria and schedulers that allocate improvement effort between model parameters and scaffold components (prompts, memory, tools, control logic).
- Causal attribution and credit assignment: methods to isolate the causal impact of each self-modification (e.g., prompt vs memory vs tool vs parameter change), including counterfactual evaluation and interventional testing.
- Unified evaluation for longitudinal self-improvement: standardized, reproducible protocols that track capability trajectories over many iterations, under non-stationary conditions and across domains with verifiable rewards.
- Reliability and calibration of judge-based evaluation: quantifying bias/drift in agent-as-a-judge setups, establishing ground-truth anchoring, calibration techniques, and standards for inter-judge agreement and auditability.
- Data flywheel integrity for intrinsic generation: mechanisms to prevent echo chambers, model collapse, and contamination when training on self-produced data; diversity/novelty constraints, deduplication, and coverage metrics.
- Safety against goal drift and specification gaming: formal methods and practical guardrails that constrain self-modifications to safe regions (e.g., verifiable invariants, proof obligations, or policy shields).
- Automated rollback and self-degradation detection: general-purpose backtracking/undo mechanisms (e.g., success-story-style acceptance tests) adapted to modern agents to detect, quarantine, and revert harmful updates.
- Memory governance at scale: strategies for memory growth control, consistency checking, provenance tracking, privacy preservation, and poisoning resistance; principled forgetting/summarization and integrity constraints.
- Secure, verifiable tool evolution: trust frameworks for dynamic tool routing, tool refinement, and autonomous tool creation (sandboxing, permissioning, interface schemas, versioning, and vulnerability surface reduction).
- Sim2real fidelity gaps for proxy environments: quantifying and bounding transfer error from simulated/self-play worlds to real environments; acceptance criteria for deploying updates derived from proxies.
- Adversarial robustness of improvement loops: defenses against prompt injection, malicious tools/webpages, and data poisoning that could corrupt self-generated signals or steer self-modification.
- Compute- and cost-aware self-improvement: budgeted optimization, stopping rules, and sample-efficient designs that trade off marginal gains vs. inference/training/tooling costs.
- Scaling laws and return-on-iteration: empirical/theoretical characterizations of diminishing returns, data/compute scaling, and asymptotic behavior of iterative self-improvement.
- Multi-agent self-improvement dynamics: stability and safety in populations (evolutionary or cooperative), credit assignment among agents, emergent collusion/competition, and convergence properties.
- Change control for scaffold/harness updates: CI/CD-style pipelines, differential testing, and formal interfaces for agent-edited harnesses to prevent regressions and ensure safe deployment.
- Legal/IP and compliance for self-generated and tool-mediated data: licensing of synthetic data, attribution for synthesized artifacts, privacy of collected experiences, and compliance in autonomous modification.
- Interoperability and portability: standards to transfer improved scaffolds across foundation models, cross-model alignment of tools/memory, and parameter-efficient adaptation vs. full fine-tuning.
- RAG/memory vs. fine-tuning trade-off: decision procedures to choose retrieval/memory updates vs. parameter updates, including hybrid strategies and interference mitigation.
- Continual learning under non-stationarity: mechanisms to maintain or improve performance across shifting distributions (avoid catastrophic forgetting) with principled evaluation under drift.
- Calibration of intrinsic evaluators/constitutions: learning and validating internal rubrics (e.g., self-critiques, constitutions) to reduce bias, overconfidence, and reward-misalignment in self-feedback.
- Provenance-aware reproducibility: community standards for releasing iterative histories (seeds, checkpoints, tool versions, memory diffs), enabling independent replication of self-improvement trajectories.
- Open-endedness vs. goal-directed control: metrics and safeguards for creative exploration without sacrificing safety and task performance; operational definitions of โenough improvementโ and termination criteria.
- Practical approximations to Gรถdel Machines: implementable, resource-bounded proof-search or program-analysis methods that guarantee expected-utility improvements of self-modifications.
- Under-served domains with verifiable rewards: richer, high-fidelity environments for embodied robotics, scientific discovery, and high-stakes settings with ground-truth verification and safe deployment pathways.
- Quantifying and minimizing human oversight: methods to measure, bound, and strategically allocate minimal human input (and audit load) while preserving safety and accountability.
- End-to-end information-flow security: principled controls and audits for memory, tool, and web channels to prevent leakage, tampering, or cross-channel escalation induced by self-modifications.
Practical Applications
Practical Applications of โSelf-Improvements in Modern Agentic Systems: A Surveyโ
This survey proposes a system-level view of self-improving agents composed of a foundation model (FM) wrapped by a modifiable operational scaffold (prompts, memory, tools, control logic). Two improvement pathways emerge: (1) foundation-model improvement (data generation, intrinsic evaluative feedback, extrinsic experience) and (2) scaffold improvement (prompt/memory/tool/full-harness updates). Below are deployable and longer-horizon applications that flow from these mechanisms, mapped to sectors and grounded with assumptions and dependencies.
Immediate Applications
- Software engineering and DevOps (industry: software)
- Use case: Self-improving coding agents integrated into CI/CD to triage issues, draft patches, write tests, and iteratively refine prompts/tools based on pass/fail signals (SWE-bench-style). Leverage scaffold updates (prompt optimization, Reflexion-like self-critique), memory of code patterns, and dynamic tool routing (linters, build/test systems).
- Tools/workflows: Agentic RAG on codebase; test-driven improvement loops; harness auto-tuning; evaluation agents to gate merges.
- Assumptions/dependencies: High-quality unit/integration tests as ground truth; repo/tool API access; sandboxing; robust rollback; cost controls for multi-iteration loops.
- Enterprise RPA and web automation (industry: software, operations)
- Use case: Web agents that self-improve task success on enterprise apps (CRM, ERP, ticketing) via prompt evolution and simulated practice (WebArena/Mind2Web-like), with memory for site-specific quirks and tool orchestration (form parsers, OCR).
- Tools/workflows: Population-based prompt evolution; textual gradients for prompt tweaks; drift detection; simulated pre-training environments before live rollout.
- Assumptions/dependencies: Stable DOM/UX or resilience to changes; safe credential handling; audit logs; allowlists and improvement gates.
- Knowledge management and enterprise search (industry: software)
- Use case: Agentic RAG systems that self-improve retrieval chains and answer verification by evolving memory objects (reasoning traces, cheat-sheets), refining retrieval prompts, and using judge-agents for answer checks.
- Tools/workflows: Memory banks of past solved queries; query reformulation via self-critique; evidence attribution; agent-as-a-judge scoring to prevent hallucination.
- Assumptions/dependencies: Index freshness; access control alignment with retrieval; verifiable citations; feedback channels (helpfulness ratings).
- Customer support and operations copilot (industry: software, services)
- Use case: Agents that self-refine response templates, escalation policies, and tool calls (ticketing/CRM) using qualitative feedback and scalar success metrics (CSAT, first-contact resolution).
- Tools/workflows: Reflexion/Self-Refine loops; memory of customer history/preferences; safe-tool routers; multi-agent debate for complex cases.
- Assumptions/dependencies: Human-in-the-loop gating; PII compliance; reliable KPI instrumentation to avoid reward hacking.
- Tool orchestration platforms (industry: software platforms)
- Use case: Dynamic tool routers that learn which API/tool to call, in what order, and with what parameters; discovery of new tools from code repos and automatic registration in the harness.
- Tools/workflows: MCP-like flows for tool discovery; meta-planning for tool sequences; cost/latency-aware routing; tool-quality feedback for continual improvement.
- Assumptions/dependencies: Tool schema standardization; rate-limit management; error taxonomies to learn from failures.
- Education and training (sector: education)
- Use case: Adaptive tutors that self-improve prompts, hints, and curriculum sequencing based on student outcomes and intrinsic evaluative feedback; memory of learner models for personalization.
- Tools/workflows: Population-based prompt evolution per learner cluster; agentic memory of misconceptions; question generation/refinement pipelines.
- Assumptions/dependencies: Ground-truth assessments; privacy and parental/IRB guardrails; content moderation; transparency of self-modifications.
- Personal productivity assistants (daily life)
- Use case: Assistants that learn user preferences (email triage, calendaring, task planning) via scaffold updates to memory and prompts; constrained tool use (email/notes/calendar APIs).
- Tools/workflows: Long-term memory with forgetting/consent controls; on-device or encrypted storage; self-critique for over-delegation and safety.
- Assumptions/dependencies: Strong privacy; explicit approval flows; safe defaults; clear activity logs.
- Scientific literature review and synthesis (academia, pharma/biotech)
- Use case: Self-improving research agents that evolve search strategies, claim checking, and evidence ranking to produce living reviews and research digests.
- Tools/workflows: Evaluator agents for verification; memory of prior syntheses; targeted prompt optimization per subfield; retrieval chains tuned by citation precision/recall.
- Assumptions/dependencies: Access to full texts/metadata; robust citation and quote checking; domain expert audits.
- Evaluation and governance tooling for AI teams (industry, policy, academia)
- Use case: Automated improvement measurement and gating pipelines that separate mechanism-level metrics (prompt/memory/tool changes) from task-level performance; judge-agents for comparative evaluation.
- Tools/workflows: Bench suites (e.g., WorkArena, MINT, SWE-bench+); agent-as-a-judge with calibration; sandboxed A/B testing; improvement logs with provenance.
- Assumptions/dependencies: Reliable evaluators and reference data; anti-gaming protections; versioned harness configs.
- Healthcare administration copilots (industry: healthcare operations)
- Use case: Agents that self-refine prompts for prior authorizations, scheduling, billing codes, and patient communications using structured toolchains (EHR APIs) and success feedback (denial rates, turnaround times).
- Tools/workflows: Tool routing to EHR and payer portals; templated self-critique with compliance checks; memory of payer policies.
- Assumptions/dependencies: HIPAA/PHI compliance; human review; narrow scope (non-diagnostic); auditable changes.
- Finance ops and reporting (industry: finance)
- Use case: Self-improving agents for reconciliations, regulatory report drafting, and data pipeline validation using deterministic checks as feedback and cautious tool orchestration (ledger systems).
- Tools/workflows: Rule-based validators as intrinsic evaluators; memory of recurring discrepancies; conservative improvement gates.
- Assumptions/dependencies: Strict access controls; segregation of duties; audit trails; robust unit tests for calculations.
- Desktop/computer-use agents (industry: IT, daily life)
- Use case: Agents that control applications to execute workflows (document processing, spreadsheet analytics), improving via testable scripts and prompt/tool refinement; safe sandboxes and rollbacks.
- Tools/workflows: OSWorld-like tasks; skill libraries that auto-refactor after failures; replay buffers for debugging.
- Assumptions/dependencies: OS/app compatibility; permissioning; deterministic replays for measurement.
Long-Term Applications
- Autonomous code-rewriting and provably beneficial self-modification (industry: software; cross-sector safety)
- Use case: Gรถdelesque agents that rewrite parts of their own learning and control code only when verifiably utility-improving.
- Tools/products: Formal proof search integrated with agent harness; verifiable improvement theorems; certified rollback.
- Dependencies: Scalable formal verification; tractable proof search; strong sandboxing; regulatory acceptance.
- Open-world autonomous tool and skill ecosystems (industry: platforms; education; robotics)
- Use case: Agents that invent, evaluate, and publish tools/skills; markets for skill composition; continual co-evolution of capabilities across organizations.
- Tools/products: Tool registries with quality scores; automated API schema induction; cross-agent skill transfer.
- Dependencies: Standards for tool metadata/safety; IP/licensing frameworks; robust misuse detection.
- Closed-loop scientific discovery and lab automation (academia, pharma, materials)
- Use case: Agents generate hypotheses, design experiments, control lab robots/instruments, and self-improve via outcome feedback and causal/world-model refinement.
- Tools/products: World-model-guided planners; instrument drivers with safety interlocks; autonomous data curation and lab notebooks.
- Dependencies: High-fidelity simulators; accurate causal feedback; biosafety/ethics/IRB; human oversight.
- Lifelong embodied and household robots (industry: robotics; healthcare)
- Use case: Robots that build self-improving world models, adapt skills in the wild, and safely learn routines (elder care assistance, logistics) with verifiable tool use.
- Tools/products: Continual-learning policies; failure-aware memory; formal safety shields; on-device learning stacks.
- Dependencies: Robust perception/manipulation; safety certification; cost-effective on-device compute; long-tail risk mitigation.
- Enterprise-scale self-redesigning agent organizations (industry: cross-sector)
- Use case: Multi-agent โorgsโ that optimize workflows, staffing of skills, and communication protocols, continually redesigning their harness to improve throughput/cost/quality.
- Tools/products: Org-level evaluators; workflow DAG optimizers; budgeted improvement planners; compliance observability.
- Dependencies: Clear OKRs and ground-truth metrics; change-management processes; security and segregation of duties.
- Clinical decision support with self-improvement (industry: healthcare)
- Use case: Agents that iteratively refine diagnostic reasoning and care pathways using intrinsic evaluators and outcome data under strict guardrails.
- Tools/products: Verifier agents that cross-check against guidelines; causal inference modules; audit-first improvement gates.
- Dependencies: Clinical trials and post-market surveillance; bias/fairness controls; regulatory approvals.
- Power systems and energy optimization (industry: energy)
- Use case: Self-improving agents for power flow optimization, demand response, and grid anomaly management with provable safety.
- Tools/products: Verifiable optimization layers; digital twins of grids; tool routers for SCADA interfaces.
- Dependencies: Real-time constraints; certified controllers; cyber-physical security; regulator buy-in.
- Financial trading and risk management (industry: finance)
- Use case: Agents that self-improve strategies using simulated market world models and judge-based evaluation; robust guardrails for risk and compliance.
- Tools/products: Market simulators calibrated to regimes; policy verifiers; kill-switch governance.
- Dependencies: Model risk management; adversarial stress testing; regulatory reporting.
- National/regulatory governance of self-improving agents (policy)
- Use case: Standards for improvement provenance, judge-agent validation, rollback requirements, and sandboxes for high-risk domains.
- Tools/products: Reference benchmarks and certs; audit APIs; tamper-evident improvement logs.
- Dependencies: Multistakeholder standards; alignment with sectoral regulators; international harmonization.
- Lifelong learning mentors and evolving curricula (education)
- Use case: Agents that maintain rich learner models, generate adaptive curricula, and refine teaching strategies with causal feedback and fairness constraints.
- Tools/products: Curriculum world models; normative evaluators; parent/teacher oversight dashboards.
- Dependencies: Consent and privacy; outcome measurement beyond test scores; bias and access equity.
- Open-ended world modeling for general agents (cross-sector)
- Use case: Agents that learn panoramic world models spanning web, software, and physical domains to generalize across tasks and self-improve efficiently.
- Tools/products: Cross-domain data engines; consistency-checking judges; hierarchical memory substrates.
- Dependencies: Data sharing agreements; robust transfer learning; scalable memory management and forgetting.
- Autonomous maintenance engineers for legacy infrastructure (industry: software/IT)
- Use case: Agents that continuously refactor, patch, and document large legacy systems, coordinating with humans and other agents, with verifiable improvement criteria.
- Tools/products: Harnesses that encode organizational coding standards; regression-proofers; change-impact simulators.
- Dependencies: Comprehensive test coverage; access to run-time telemetry; strict change controls.
Notes on cross-cutting assumptions
- Reliable improvement signals: unit tests, verifiable metrics, judge-agents, or verifiable environments are necessary to avoid drift and reward hacking.
- Safety and governance: sandboxing, provenance of self-modifications, reversible updates, and human-in-the-loop gates are essential for high-stakes domains.
- Data and privacy: memory systems must honor data minimization, consent, retention limits, and encryption; domain-specific compliance (HIPAA, GDPR, SOX).
- Cost/latency and MLOps: online/self-improving loops require budget-aware planning, caching, observability, and rollback playbooks.
- Tooling ecosystems: widespread benefit depends on standardizing tool schemas/registries, evaluation protocols, and reproducible benchmarks.
Glossary
- AIXI: A theoretical model of an optimal, but uncomputable, reinforcement-learning agent for computable environments. Example: "AIXI formalized an uncomputable upper bound on optimal sequential decision-making in computable environments"
- Agent {harness}: An alternative name for the surrounding control structures and interfaces that wrap a foundation model to form an agent. Example: "agent {harness}"
- Agentic RAG: A retrieval-augmented generation approach embedded in agent workflows to integrate external knowledge at decision time. Example: "Agentic RAG"
- Agentic systems: AI systems designed to perceive, decide, and act autonomously in pursuit of goals, often with iterative reasoning and tool use. Example: "agentic systems"
- Amortizing capability gains: Consolidating learned improvements into the model so benefits transfer across tasks without re-learning each time. Example: "amortizing capability gains across varied tasks"
- Chain of thought: A prompting and reasoning technique where models produce step-by-step rationales before final answers. Example: "akin to a modern \"chain of thought\""
- Closed-loop systems: Systems that use feedback from the environment to regulate their behavior and adapt. Example: "closed-loop systems"
- Control logic: The decision-making and coordination procedures that govern an agentโs planning, tool use, and action selection. Example: "control logic"
- Core-and-scaffold architecture: A design where a foundation model (core) is coupled with an external scaffold for memory, tools, and control. Example: "core-and-scaffold architecture"
- Credit assignment mechanism: Procedures for attributing outcomes to specific decisions or components so the system can improve the right parts. Example: "credit assignment mechanism"
- Cybernetics: The study of control and communication in animals and machines that popularized feedback-based adaptation. Example: "Cybernetics"
- Extrinsic exploratory experience: Improvement signals derived from interacting with external environments or tasks, beyond self-generated data. Example: "extrinsic exploratory experience"
- Fast weights: Rapidly updated parameters that allow a neural network to modify its own behavior on short timescales. Example: "fast weights"
- Foundation models (FMs): Large pre-trained models (e.g., LLMs, VLMs) that can be adapted to many downstream tasks. Example: "foundation models (FMs)"
- Foundation Model Improvement: The pathway that updates the modelโs parameters to consolidate and generalize capability gains. Example: "Foundation Model Improvement"
- G\"odel Machine: A fully self-referential agent that rewrites its own code once it can prove the change improves expected utility. Example: "G\"odel Machine"
- Homeostasis: The process by which a system maintains internal stability in the face of external changes. Example: "homeostasis"
- Inductive bias: The set of assumptions a learning system uses to generalize beyond observed data. Example: "inductive bias"
- Intelligence Explosion: A hypothesized runaway feedback loop where self-improving machines rapidly surpass human intelligence. Example: "``Intelligence Explosion''"
- Intrinsic evaluative feedback: Self-generated assessments or critiques that guide improvement without external labels. Example: "intrinsic evaluative feedback"
- Intrinsic generative demonstrations: Training examples produced by the agent or model itself to teach or refine capabilities. Example: "intrinsic generative demonstrations"
- Meta-learning: Learning how to learn; systems that acquire or adapt their own learning algorithms or strategies. Example: "meta-learning systems"
- NeuroEvolution of Augmenting Topologies (NEAT): An evolutionary method that jointly optimizes neural network weights and architectures. Example: "NeuroEvolution of Augmenting Topologies (NEAT)"
- Observation and action semantics: The representational structure an agent uses to interpret inputs and specify outputs. Example: "observation and action semantics"
- Operational scaffold: The surrounding, modifiable components (prompts, memory, tools, control) that operationalize a model as an agent. Example: "operational scaffold"
- Outer-product updates: A fast-weight update rule where parameter changes are computed via vector outer products. Example: "outer-product updates"
- Prompt optimization: Improving prompt instructions and structures to enhance model or agent performance on tasks. Example: "prompt optimization"
- Scaffolding Improvement: The pathway that adapts non-parametric structures like prompts, memory, tools, and workflows. Example: "Scaffolding Improvement"
- Self-induced update operator: A formal mechanism by which an agent identifies and commits its own parameter or scaffold updates. Example: "self-induced update operator"
- Self-referential: A system property where components can represent and modify themselves or their own procedures. Example: "self-referential"
- Self-referential learning framework: An approach where the learning system can generate and evaluate modified versions of itself. Example: "self-referential learning framework"
- Self-referential weight matrices: Neural architectures where the network learns rules to update its own weights. Example: "self-referential weight matrices"
- Self-reproducing automata: Formal systems capable of constructing copies or variants of themselves from symbolic descriptions. Example: "self-reproducing automata"
- Single-life reinforcement learning environment: An RL setting where an agent optimizes behavior over a single, continuous lifetime of interaction. Example: "single-life reinforcement learning environment"
- Success-story algorithm: A self-improvement method that enforces long-term reward acceleration and can undo harmful self-modifications. Example: "success-story algorithm"
- Tool governance: Policies and mechanisms for selecting, constraining, and auditing tool use within an agent. Example: "tool governance"
- Tool interfaces: APIs and connectors that allow agents to invoke external tools and services. Example: "tool interfaces"
- Unnormalized linear Transformer (ULTRA): An early Transformer-like fast-weight architecture based on linear attention without normalization. Example: "unnormalized linear Transformer (ULTRA)"
- Update signal: A computed measure or feedback that triggers changes to the model or scaffold. Example: "update signal"
- World model: An internal model that predicts or simulates aspects of the environment to support planning and reasoning. Example: "world model"
Collections
Sign up for free to add this paper to one or more collections.