BestHub
Sign in
Tagged articles

Memory Management

1009 articles · Page 2 of 11
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 27, 2026 · Artificial Intelligence

How Tair Powers Sub‑Second AI Agent Memory for Real‑Time Ordering

This article examines how Taobao Flash Sale’s AI Agent uses Alibaba Cloud’s Tair as a high‑performance short‑term memory layer, detailing data model design, latency impact, concurrency control, elastic scaling, bandwidth handling, and TTL‑based cleanup to achieve sub‑second response times during massive traffic spikes.

AI AgentDistributed LockMemory Management
0 likes · 15 min read
How Tair Powers Sub‑Second AI Agent Memory for Real‑Time Ordering
Amazon Cloud Developers
Amazon Cloud Developers
Mar 27, 2026 · Artificial Intelligence

Deploy a Fast‑Fashion E‑Commerce AI Agent in Days to Handle Millions of Concurrent Queries

This article provides a comprehensive, step‑by‑step guide on using Amazon Bedrock AgentCore Runtime to quickly build, deploy, and scale AI agents for fast‑fashion e‑commerce scenarios—covering architecture, supported protocols, session isolation, asynchronous processing, memory management, code examples, and multi‑agent coordination—enabling millions of simultaneous customer interactions with enterprise‑grade security and reliability.

AI AgentAWS BedrockAgentCore Runtime
0 likes · 40 min read
Deploy a Fast‑Fashion E‑Commerce AI Agent in Days to Handle Millions of Concurrent Queries
Su San Talks Tech
Su San Talks Tech
Mar 26, 2026 · Artificial Intelligence

Unlocking AI Agents: How OpenClaw Turns Language Models into Actionable Bots

This article explains how OpenClaw functions as an AI Agent framework that connects chat applications to large language models, manages multi‑turn dialogues, executes tool commands, handles memory and security, and demonstrates advanced features such as sub‑agents, cron jobs, and context compression.

AI AgentMemory ManagementOpenClaw
0 likes · 19 min read
Unlocking AI Agents: How OpenClaw Turns Language Models into Actionable Bots
AI Waka
AI Waka
Mar 25, 2026 · Artificial Intelligence

How OpenClaw Turns Your Machine into an Autonomous AI Agent Runtime

OpenClaw is an open‑source, OS‑level autonomous agent runtime that combines dynamic system prompts, powerful tool access, file‑based memory, and sub‑agent generation, offering a secure, extensible architecture that runs on a single Node.js process and integrates with any LLM provider.

Agent RuntimeAutonomous AgentsLLM integration
0 likes · 19 min read
How OpenClaw Turns Your Machine into an Autonomous AI Agent Runtime
ITPUB
ITPUB
Mar 21, 2026 · Backend Development

What Linus Missed in Git’s Init: Deep Dive into C Code and Memory Leaks

The article examines Linus Torvalds’s original Git init implementation, walking through the C source files, explaining how directories are created, why a 40‑byte offset is added to allocated memory, and highlighting a missing free() call that leads to a memory leak, while discussing when manual deallocation is necessary.

C ProgrammingGitMemory Management
0 likes · 8 min read
What Linus Missed in Git’s Init: Deep Dive into C Code and Memory Leaks
AI Step-by-Step
AI Step-by-Step
Mar 16, 2026 · Artificial Intelligence

Boost Your OpenClaw with 5 Essential Skills

After installing OpenClaw, adding the five plugins—memory, ontology, proactive‑agent, self‑improving‑agent, and Trello—transforms the chatbot from basic conversation to a context‑aware, structured‑knowledge, proactive, self‑learning system with integrated task management.

Memory ManagementOntologyOpenClaw
0 likes · 5 min read
Boost Your OpenClaw with 5 Essential Skills
Architect's Ambition
Architect's Ambition
Mar 16, 2026 · Artificial Intelligence

Understanding AI Agents: From Chatting to Getting Things Done

The article explains the four essential components of AI Agents—brain, memory, tool, and planning layers—illustrates their implementation with Python code, compares planning strategies, shares a real-world OOM fault‑diagnosis case, and lists common pitfalls to help newcomers build functional agents.

AI AgentLLMMemory Management
0 likes · 17 min read
Understanding AI Agents: From Chatting to Getting Things Done
Deepin Linux
Deepin Linux
Mar 14, 2026 · Fundamentals

Mastering Linux CMA: How the Contiguous Memory Allocator Solves Fragmentation

This article explains the challenges of allocating large contiguous physical memory in Linux, introduces the Contiguous Memory Allocator (CMA) as a solution, and provides in‑depth coverage of its design, reservation, migration, data structures, initialization, configuration, usage in drivers, and debugging techniques.

CMAContiguous Memory AllocatorDMA
0 likes · 35 min read
Mastering Linux CMA: How the Contiguous Memory Allocator Solves Fragmentation
NiuNiu MaTe
NiuNiu MaTe
Mar 13, 2026 · Artificial Intelligence

OpenClaw Explained: Turning Your PC into a Local AI Agent (Architecture & Risks)

OpenClaw is a locally‑run AI agent that listens to messages from multiple platforms, translates them into a unified format, uses an LLM to plan actions, executes tasks via modular Skills, and stores context in a transparent local memory, while exposing significant security considerations.

AI AgentLocal AutomationMemory Management
0 likes · 10 min read
OpenClaw Explained: Turning Your PC into a Local AI Agent (Architecture & Risks)
Deepin Linux
Deepin Linux
Mar 13, 2026 · Fundamentals

How Does the MMU Translate Virtual to Physical Memory? A Deep Dive

This article explains the role of the Memory Management Unit (MMU) and paging in modern operating systems, covering hardware structure, address translation, permission checks, page tables, TLB behavior, virtual memory mechanisms, and practical Linux kernel code examples for memory protection, sharing, and performance optimization.

LinuxMMUMemory Management
0 likes · 58 min read
How Does the MMU Translate Virtual to Physical Memory? A Deep Dive
Java Architect Handbook
Java Architect Handbook
Mar 12, 2026 · Backend Development

How Many Objects Does new String("abc") Actually Create?

This article explains why the interview question "String str = new String(\"abc\")" can create either one or two objects depending on JVM string pool state, detailing the JVM memory model, string pool mechanics, code examples, best practices, and common misconceptions.

JVMMemory ManagementObject Creation
0 likes · 9 min read
How Many Objects Does new String("abc") Actually Create?
Wu Shixiong's Large Model Academy
Wu Shixiong's Large Model Academy
Mar 12, 2026 · Artificial Intelligence

How to Build Cross-Session Memory for RAG Chatbots: Short‑Term vs Long‑Term Strategies

This article explains the role of memory modules in Retrieval‑Augmented Generation systems, compares short‑term and long‑term memory techniques, outlines storage and retrieval methods, discusses management strategies like forgetting and deduplication, and compares LangChain and LlamaIndex implementations for practical deployment.

LLMLangChainLlamaIndex
0 likes · 11 min read
How to Build Cross-Session Memory for RAG Chatbots: Short‑Term vs Long‑Term Strategies
Fun with Large Models
Fun with Large Models
Mar 11, 2026 · Artificial Intelligence

LangChain DeepAgents Quick Guide – FileSystem Middleware Gives AI Agents System‑Level Memory Management

This article explains why AI agents need a memory‑management solution, introduces LangChain DeepAgents' FileSystem middleware, details its four backend options for short‑term, long‑term, disk‑based, and hybrid storage, and provides step‑by‑step Python examples for installing, configuring, and using the middleware in real‑world scenarios.

AI AgentDeepAgentsFileSystemMiddleware
0 likes · 16 min read
LangChain DeepAgents Quick Guide – FileSystem Middleware Gives AI Agents System‑Level Memory Management
PaperAgent
PaperAgent
Mar 10, 2026 · Artificial Intelligence

How MemSifter Delivers High‑Precision, Low‑Cost Long‑Term Memory for LLMs

MemSifter introduces a lightweight agent that outsources memory retrieval for large language models, using a Think‑and‑Rank pipeline and a task‑result‑oriented reinforcement‑learning training paradigm to achieve superior retrieval accuracy and efficiency across eight benchmark tasks while keeping inference overhead minimal.

AgentEfficiencyLLM
0 likes · 13 min read
How MemSifter Delivers High‑Precision, Low‑Cost Long‑Term Memory for LLMs
AI Architecture Hub
AI Architecture Hub
Mar 8, 2026 · Artificial Intelligence

How OpenClaw Tackles Real-World AI Agent Engineering Challenges

This article analyzes the engineering bottlenecks of AI agents and presents OpenClaw—a TypeScript‑based CLI system that solves concurrency, state traceability, failure explainability, memory management, and security through a clear pipeline and practical design patterns, offering ten ready‑to‑use implementation tips.

AI AgentsMemory ManagementOpenClaw
0 likes · 16 min read
How OpenClaw Tackles Real-World AI Agent Engineering Challenges
Coder Trainee
Coder Trainee
Mar 5, 2026 · Operations

Why is Linux’s buff/cache so large and how to clear it automatically

When running `free -h` on a Linux system, you may notice the buff/cache entry consuming over a gigabyte, leaving little memory for applications; this article explains that the cache is built from file I/O, shows how to manually drop it via `/proc/sys/vm/drop_caches`, and provides a cron‑based script to automate the cleanup.

LinuxMemory Managementbuff/cache
0 likes · 4 min read
Why is Linux’s buff/cache so large and how to clear it automatically
Machine Learning Algorithms & Natural Language Processing
Machine Learning Algorithms & Natural Language Processing
Mar 4, 2026 · Artificial Intelligence

How to Build a 24‑Hour AI Agent Team with OpenClaw – A Real‑World Walkthrough

The author details a month‑long experiment creating a six‑agent AI team with OpenClaw that automates research, content creation, code review and email newsletters, saving 4‑5 hours each day for under $400 per month by using file‑based coordination, a two‑layer memory system, and a gradual rollout plan.

AI AgentsMemory ManagementOpenClaw
0 likes · 14 min read
How to Build a 24‑Hour AI Agent Team with OpenClaw – A Real‑World Walkthrough
DeepHub IMBA
DeepHub IMBA
Mar 3, 2026 · Artificial Intelligence

The Evolution of KV Cache Management: From Continuous Allocation to Unified Hybrid Memory Architecture

The article traces five eras of KV cache management for LLM inference—from its absence before Transformers to the emerging unified hybrid memory architecture—comparing vLLM, SGLang, and TensorRT‑LLM and offering a decision framework for selecting the right solution in various deployment scenarios.

KV cacheLLM InferenceMemory Management
0 likes · 16 min read
The Evolution of KV Cache Management: From Continuous Allocation to Unified Hybrid Memory Architecture
Deepin Linux
Deepin Linux
Feb 27, 2026 · Fundamentals

Unlocking Linux Memory Management: From Virtual Memory to Kernel Allocation

This article explains Linux’s comprehensive memory management system, covering physical and virtual memory concepts, paging, page tables, the MMU, the buddy allocator, slab allocator, memory reclamation strategies such as LRU and swap, monitoring tools, and practical optimization techniques for both user‑space and kernel‑space allocations.

LinuxMMUMemory Management
0 likes · 31 min read
Unlocking Linux Memory Management: From Virtual Memory to Kernel Allocation
Golang Shines
Golang Shines
Feb 26, 2026 · Fundamentals

Rust vs Go Memory Management: The Caretaker vs the Landlord

This article compares Rust and Go memory management by using a house‑rental analogy, detailing Go's garbage‑collector landlord model and Rust's compile‑time caretaker model, illustrating each with code snippets, pros and cons, real‑world performance anecdotes, and a practical scenario matrix.

Garbage CollectionGoMemory Management
0 likes · 7 min read
Rust vs Go Memory Management: The Caretaker vs the Landlord
TonyBai
TonyBai
Feb 26, 2026 · Backend Development

Can Zig Replace Rust and Go? A Deep Dive into System‑Level Programming

The article follows a senior Go developer who migrated a mutex‑based key/value store from Go to Zig 0.16, comparing language ergonomics, memory management, concurrency models, code size, and ecosystem maturity, and concludes whether Zig can become the ultimate system‑programming choice.

GoMemory ManagementZig
0 likes · 14 min read
Can Zig Replace Rust and Go? A Deep Dive into System‑Level Programming
Shuge Unlimited
Shuge Unlimited
Feb 23, 2026 · Artificial Intelligence

How OpenClaw Memory Gives AI Agents 24/7 Long‑Term Memory

The article explains OpenClaw Memory's design—storing daily and permanent logs as Markdown files, managing them with Git, offering hybrid vector‑BM25 search, applying temporal decay to prioritize recent entries, and comparing SQLite and QMD backends with practical configuration examples and tips.

AI AgentHybrid SearchMemory Management
0 likes · 14 min read
How OpenClaw Memory Gives AI Agents 24/7 Long‑Term Memory
Architect
Architect
Feb 20, 2026 · Artificial Intelligence

How Agent Loops Give AI Agents a Personality: Engineering Secrets Revealed

This article explains how the Agent Loop—an engineered while‑loop that repeatedly calls an LLM, decides when to use tools, executes them, and feeds results back—creates persistence, style, memory, judgment, and safety boundaries that together make an AI agent feel like it has its own personality.

AI Agent EngineeringAgent LoopLLM
0 likes · 24 min read
How Agent Loops Give AI Agents a Personality: Engineering Secrets Revealed
Deepin Linux
Deepin Linux
Feb 20, 2026 · Fundamentals

Unlocking Zero‑Copy: How Linux Shared Memory Boosts IPC Performance

This article explains the fundamentals of Linux memory management, details how shared memory implements zero‑copy inter‑process communication, and provides step‑by‑step code examples of system calls, mmap, sendfile, splice, and synchronization techniques for high‑performance data transfer.

IPCMemory ManagementZero‑copy
0 likes · 40 min read
Unlocking Zero‑Copy: How Linux Shared Memory Boosts IPC Performance
IT Learning Made Simple
IT Learning Made Simple
Feb 12, 2026 · Fundamentals

Why Computer Fundamentals Are the Director’s Core Skills for System Architects

This chapter uses vivid analogies and exam‑focused breakdowns to explain the Von Neumann architecture, CPU performance metrics, memory hierarchy, operating‑system concepts such as processes, threads, scheduling, memory management, virtual memory, file systems and deadlock, showing how mastering these basics gives architects a decisive edge in system‑design exams.

CPUComputer ArchitectureDeadlock
0 likes · 38 min read
Why Computer Fundamentals Are the Director’s Core Skills for System Architects
Raymond Ops
Raymond Ops
Feb 11, 2026 · Databases

Mastering Redis Memory: From Basics to Advanced Troubleshooting

This comprehensive guide walks you through the real costs of Redis memory problems, explains the three‑layer memory architecture and five major consumers, provides a toolbox of INFO and MEMORY commands plus monitoring scripts, and offers step‑by‑step solutions for seven common issues, best‑practice optimizations, real‑world case studies, a daily checklist, and advanced techniques such as Lua scripts and smart cache warm‑up.

DatabasesMemory ManagementPerformance Tuning
0 likes · 26 min read
Mastering Redis Memory: From Basics to Advanced Troubleshooting
AI Large Model Application Practice
AI Large Model Application Practice
Feb 10, 2026 · Artificial Intelligence

How OpenClaw Secures Production‑Grade AI Agents with Zero‑Trust Tool Policies

This article dissects OpenClaw’s engineering techniques for building robust, production‑level AI agents, covering zero‑trust tool policies for security, markdown‑based memory management, cost‑aware reasoning levels, and controlled sub‑agent collaboration to ensure safety, efficiency, and reliability.

AI AgentsMemory Managementcost optimization
0 likes · 12 min read
How OpenClaw Secures Production‑Grade AI Agents with Zero‑Trust Tool Policies
Golang Shines
Golang Shines
Feb 6, 2026 · Fundamentals

Go 1.26 Extends built‑in new to Accept Arbitrary Expressions

Go 1.26 adds a new capability to the built‑in new function, allowing it to take any expression, copy the result into a temporary variable and return a pointer, which eliminates the need for helper functions, prevents hidden memory leaks and yields measurable performance gains, as shown by concrete benchmarks and compiler‑level escape‑analysis explanations.

Escape AnalysisGoMemory Management
0 likes · 8 min read
Go 1.26 Extends built‑in new to Accept Arbitrary Expressions
AI Tech Publishing
AI Tech Publishing
Feb 5, 2026 · Artificial Intelligence

From Java Backend to AI Agent Engineer: Essential Knowledge for the Transition

This comprehensive guide walks Java backend developers through the fundamentals of AI agents, comparing agents with traditional workflows, detailing core components such as LLMs, tools, and memory, and exploring practical patterns, frameworks, and code examples to help them successfully shift into AI agent development.

AI AgentsLLMMemory Management
0 likes · 35 min read
From Java Backend to AI Agent Engineer: Essential Knowledge for the Transition
Wuming AI
Wuming AI
Feb 3, 2026 · Artificial Intelligence

How Short‑Term vs Long‑Term Memory Works in LLM‑Powered Autonomous Agents

This article demystifies short‑term and long‑term memory in LLM‑driven autonomous agents, explaining their mechanisms, limitations, and practical implementations such as sliding windows, summarization, and vector‑based retrieval, while illustrating each concept with concrete Cherry Studio examples and relevant research references.

Autonomous AgentsCherry StudioLLM
0 likes · 7 min read
How Short‑Term vs Long‑Term Memory Works in LLM‑Powered Autonomous Agents
Architect
Architect
Feb 1, 2026 · Artificial Intelligence

How OpenClaw Makes AI Agents Reliable: Inside Its Architecture and Engineering Secrets

This article dissects OpenClaw’s architecture, revealing how a TypeScript CLI process, a gateway server, lane‑queue concurrency, structured memory, tool‑execution allowlists, and semantic browser snapshots combine to turn fragile AI agents into stable, observable, and controllable systems.

AI AgentsMemory ManagementReliability
0 likes · 20 min read
How OpenClaw Makes AI Agents Reliable: Inside Its Architecture and Engineering Secrets
Tech Verticals & Horizontals
Tech Verticals & Horizontals
Jan 10, 2026 · Artificial Intelligence

Essential Components of an AI Agent Architecture

The article outlines the core building blocks of AI agents—including frontend frameworks, development kits, tool integration, memory strategies, design patterns, model selection, and runtime environments—while explaining how each choice impacts performance, scalability, cost, and security.

ADKAI AgentsGoogle Cloud
0 likes · 19 min read
Essential Components of an AI Agent Architecture
AI Engineering
AI Engineering
Jan 10, 2026 · Artificial Intelligence

Teaching LLMs to Manage Memory Autonomously, Dropping Manual Rules

Alibaba's new AgeMem framework turns long‑term and short‑term memory management for large language model agents into a learnable reinforcement‑learning task, replacing handcrafted rules with a three‑stage training process and achieving significant benchmark gains.

AgeMemGRPOLLM
0 likes · 9 min read
Teaching LLMs to Manage Memory Autonomously, Dropping Manual Rules
dbaplus Community
dbaplus Community
Jan 4, 2026 · Cloud Native

Why One in a Million Searches Slowed 100× After Moving to Kubernetes

During Pinterest’s migration of its custom search platform Manas to the PinCompute Kubernetes environment, a rare latency spike—one request per million taking 100 times longer—was traced to cAdvisor’s memory‑intensive smaps scans, revealing hidden resource contention and prompting a targeted fix.

Memory ManagementPerformance debuggingPinCompute
0 likes · 13 min read
Why One in a Million Searches Slowed 100× After Moving to Kubernetes
Deepin Linux
Deepin Linux
Jan 4, 2026 · Fundamentals

Unlocking Linux Shared Memory: Deep Dive into IPC Mechanics and Implementation

This article thoroughly explains Linux shared memory, covering its advantages over other IPC methods, the kernel data structures, virtual‑physical mapping, creation and destruction APIs, copy‑on‑write behavior, and provides complete example code for inter‑process communication.

C ProgrammingIPCMemory Management
0 likes · 46 min read
Unlocking Linux Shared Memory: Deep Dive into IPC Mechanics and Implementation
LuTiao Programming
LuTiao Programming
Dec 27, 2025 · Fundamentals

What 500 Java Projects Reveal: The One Pitfall Almost Every Developer Falls Into

The article shows that most Java performance problems stem from a simple, often‑overlooked mistake—using immutable String concatenation in loops, large text building, and logging—while demonstrating how StringBuilder, proper logging placeholders, and understanding the string pool can dramatically reduce GC pressure and CPU waste.

Garbage CollectionJavaLogging
0 likes · 8 min read
What 500 Java Projects Reveal: The One Pitfall Almost Every Developer Falls Into
DataFunTalk
DataFunTalk
Dec 25, 2025 · Artificial Intelligence

How DeepAgent Redefines General AI Reasoning with Scalable Toolsets

DeepAgent, a new end‑to‑end reasoning agent, integrates autonomous thinking, dynamic tool search, and execution to handle over 16,000 APIs, embodied tasks, and research assistance, achieving state‑of‑the‑art performance on benchmarks like TMDB, ToolBench, ALFWorld, WebShop, and GAIA.

Large Language ModelMemory Managementreasoning
0 likes · 15 min read
How DeepAgent Redefines General AI Reasoning with Scalable Toolsets
Amazon Cloud Developers
Amazon Cloud Developers
Dec 18, 2025 · Artificial Intelligence

Building Agent Memory Modules: A Practical Guide for Next‑Gen Agentic AI

The article examines why large language models lack persistent state, outlines the goals and types of memory for AI agents, details design considerations, presents real‑world scenarios and case studies, and compares open‑source frameworks (Mem0, Letta, LangMem) with AWS Bedrock AgentCore’s managed memory solution.

AWS BedrockAgentic AILLM
0 likes · 26 min read
Building Agent Memory Modules: A Practical Guide for Next‑Gen Agentic AI
Deepin Linux
Deepin Linux
Dec 14, 2025 · Fundamentals

Why Linux Kernel Memory Layout Is the Hidden Key to Preventing OOM Crashes

This article reveals how Linux kernel memory layout—its partitions, address allocation, and resource scheduling—directly impacts system stability, explains the roles of each memory region, demonstrates common pitfalls like fragmentation and dentry leaks, and provides practical debugging and optimization techniques for developers and operators.

Kernel MemoryLinuxMemory Management
0 likes · 60 min read
Why Linux Kernel Memory Layout Is the Hidden Key to Preventing OOM Crashes
Deepin Linux
Deepin Linux
Dec 12, 2025 · Fundamentals

Unlocking ARM64 Memory: How Virtual Addresses Map to Physical Memory

This article explains the fundamentals of Linux arm64 memory management, covering virtual and physical memory concepts, MMU operation, page table structures, address translation steps, page fault handling, and practical C++ examples for allocation, mapping, and performance optimization using huge pages and pre‑paging techniques.

ARM64LinuxMemory Management
0 likes · 38 min read
Unlocking ARM64 Memory: How Virtual Addresses Map to Physical Memory
php Courses
php Courses
Dec 1, 2025 · Backend Development

Why PHP Memory Grows in Long‑Running Workers and How to Fix It

In long‑running PHP processes, memory usage can steadily increase due to reference counting, circular references, unreleased resources, and default garbage‑collector settings; this article explains the underlying mechanisms, common leak sources, and provides practical debugging tips and best‑practice solutions such as explicit variable cleanup, GC tuning, process restarts, and memory‑efficient extensions.

Garbage CollectionMemory ManagementPHP
0 likes · 7 min read
Why PHP Memory Grows in Long‑Running Workers and How to Fix It
Architecture and Beyond
Architecture and Beyond
Nov 29, 2025 · Backend Development

How ComfyUI Caches Work: CLASSIC vs LRU vs RAM_PRESSURE Explained

This article breaks down ComfyUI's two‑level cache system, explains the differences between the CLASSIC, LRU, and RAM_PRESSURE strategies for outputs and objects, and offers practical guidance on choosing the right cache mode when running multiple models, LoRAs, and workflows on a single machine.

AI workflowsCache StrategiesCaching
0 likes · 19 min read
How ComfyUI Caches Work: CLASSIC vs LRU vs RAM_PRESSURE Explained
Open Source Tech Hub
Open Source Tech Hub
Nov 29, 2025 · Backend Development

Why PHP Workers Never Release Memory: The Hidden Block Allocation Pattern

When moving from PHP‑FPM to long‑running processes like RoadRunner or Laravel queue workers, memory usage climbs and never drops, a pattern caused by PHP’s Zend memory manager block allocation, reference counting, and GC behavior, which can be mitigated by redesigning code and worker strategies.

Garbage CollectionMemory ManagementPHP
0 likes · 12 min read
Why PHP Workers Never Release Memory: The Hidden Block Allocation Pattern
Wu Shixiong's Large Model Academy
Wu Shixiong's Large Model Academy
Nov 27, 2025 · Artificial Intelligence

Why Your Enterprise AI Agent Fails and How to Fix the Four Biggest Pitfalls

This article explains why many enterprise AI agents break down in real projects, identifies four common pitfalls—including mistaking agents for chatbots, lacking schema‑level tool logic, missing memory and variable injection, and absent end‑to‑end pipelines—and offers concrete engineering solutions to build robust, task‑driven agents.

AI AgentEnd-to-End PipelineEnterprise AI
0 likes · 8 min read
Why Your Enterprise AI Agent Fails and How to Fix the Four Biggest Pitfalls
vivo Internet Technology
vivo Internet Technology
Nov 12, 2025 · Fundamentals

Linux Kernel Innovations Powering the AI Agent Era – Highlights from China’s 20th CLK

The 20th China Linux Kernel Developers Conference, hosted by vivo, presented eleven technical talks covering AI‑driven kernel challenges, memory‑compression techniques, heterogeneous compression, async file‑cache management, uncached I/O, direct I/O for compressed files, parallel writeback, host‑initiated defragmentation, zoned storage, energy‑efficient I/O, and eBPF‑based CPU idle policies, each with concrete performance results and implementation details.

AIFile SystemsLinux kernel
0 likes · 12 min read
Linux Kernel Innovations Powering the AI Agent Era – Highlights from China’s 20th CLK
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 12, 2025 · Artificial Intelligence

How Self‑Programming AI Agents Are Built: From LLM Brain to Dynamic Code Execution

This article explains how a self‑programming AI Agent is constructed by extending large language models as the brain, designing a multi‑area architecture, implementing memory layers, prompt engineering with segment mechanisms, and enabling code generation and execution through a Python‑Java bridge, while sharing practical insights and future directions.

AI AgentCode ExecutionLLM
0 likes · 34 min read
How Self‑Programming AI Agents Are Built: From LLM Brain to Dynamic Code Execution
Tech Stroll Journey
Tech Stroll Journey
Nov 11, 2025 · Operations

Why Swap Stays Full on Linux and How to Release 29 GB Quickly

After noticing 14 GB free RAM but a fully used 29 GB swap, the article explains how to diagnose hidden swap consumption using tools like smem and swap_stat_show, clarifies the difference between free’s Swap used and /proc/*/status VmSwap, and shows how adjusting transparent_hugepage defrag and toggling swap can reclaim the space.

LinuxMemory ManagementPerformance Tuning
0 likes · 10 min read
Why Swap Stays Full on Linux and How to Release 29 GB Quickly
Data STUDIO
Data STUDIO
Nov 4, 2025 · Artificial Intelligence

How to Build a Memory-Enabled AI Agent with SQLite and Vector Search

This article explains how to give AI agents persistent memory, reflection, and goal‑tracking by storing interaction summaries in SQLite, embedding them for semantic retrieval with a vector database, and using LLM‑generated prompts to recall, reflect, and manage objectives across sessions.

AI AgentGoal TrackingLLM
0 likes · 10 min read
How to Build a Memory-Enabled AI Agent with SQLite and Vector Search
Ops Community
Ops Community
Nov 3, 2025 · Operations

Master Linux Memory Management: Core Commands & Tuning in 10 Minutes

This comprehensive guide walks you through Linux memory management fundamentals, from prerequisite environments and a quick checklist to step‑by‑step installation of monitoring tools, memory diagnostics, kernel parameter adjustments, THP and swap optimization, NUMA affinity tuning, validation, Prometheus alerts, security hardening, troubleshooting, rollback procedures, best‑practice recommendations, and ready‑to‑use scripts and configuration snippets.

LinuxMemory ManagementPerformance Tuning
0 likes · 24 min read
Master Linux Memory Management: Core Commands & Tuning in 10 Minutes
AndroidPub
AndroidPub
Nov 3, 2025 · Mobile Development

How Android 15’s 16KB Memory Pages Boost Performance and Meet Play Store Rules

Android 15 introduces 16KB memory pages, requiring native libraries to align accordingly; this change improves TLB efficiency, reduces CPU load, speeds up cold starts, and lowers battery consumption, while Google Play mandates compliance by November 2025, prompting developers to audit and rebuild affected .so files using provided tools.

16KBAndroidMemory Management
0 likes · 12 min read
How Android 15’s 16KB Memory Pages Boost Performance and Meet Play Store Rules
vivo Internet Technology
vivo Internet Technology
Oct 29, 2025 · Databases

Why Did Redis Keys Suddenly Disappear? A Deep Dive into Memory Exhaustion and Client Buffer Overflow

This article analyzes a production incident where Redis failed to retrieve keys at 2 AM, tracing the root cause to a short‑term memory write‑full condition caused by massive GET request bursts that overflowed client output buffers, and outlines both emergency fixes and long‑term mitigations.

Client Buffer OverflowMemory ManagementRedis
0 likes · 10 min read
Why Did Redis Keys Suddenly Disappear? A Deep Dive into Memory Exhaustion and Client Buffer Overflow
Linux Kernel Journey
Linux Kernel Journey
Oct 27, 2025 · Fundamentals

Exploring eBPF‑Based Programmable Memory Management in the Linux Kernel

This article examines recent efforts to make Linux kernel memory management programmable with eBPF, covering BPF‑MM patches for mTHP order, cache‑ext’s customizable LRU, FetchBPF prefetch policies, and BPF OOM hooks, and discusses their design, implementation details, and performance impacts.

LRULinux kernelMemory Management
0 likes · 8 min read
Exploring eBPF‑Based Programmable Memory Management in the Linux Kernel
Tech Stroll Journey
Tech Stroll Journey
Oct 22, 2025 · Fundamentals

Understanding Linux Swap: How It Works, Tuning Tips, and Common Cleanup Commands

Linux swap provides a disk‑backed memory extension, storing anonymous pages when RAM runs low; this article explains swap’s operation, the kernel’s memory reclamation thresholds, tuning parameters like min_free_kbytes and swappiness, and offers commands to locate high‑swap processes and safely clear swap.

LinuxMemory Managementkernel tuning
0 likes · 7 min read
Understanding Linux Swap: How It Works, Tuning Tips, and Common Cleanup Commands
Data STUDIO
Data STUDIO
Oct 21, 2025 · Artificial Intelligence

Building a Self‑Learning LangGraph Memory System with Feedback Loops and Dynamic Prompts

This article walks through the design and implementation of a two‑layer memory architecture for LangGraph agents, covering short‑term and long‑term stores, various storage back‑ends, prompt engineering, utility functions, node definitions, human‑in‑the‑loop interrupt handling, and how user feedback is captured and used to continuously update the agent’s behavior.

AgentFeedback LoopLLM
0 likes · 43 min read
Building a Self‑Learning LangGraph Memory System with Feedback Loops and Dynamic Prompts
Top Architect
Top Architect
Oct 15, 2025 · Backend Development

How to Tune JVM for 1M Daily Logins on an 8 GB Server

This article walks through a step‑by‑step guide for configuring JVM memory, selecting the right garbage collector, and fine‑tuning parameters to reliably handle a platform receiving one million login requests per day on a service node with 8 GB RAM, covering capacity planning, GC choice, heap sizing, thread stack, object aging, and monitoring.

Garbage CollectionJVMJava
0 likes · 27 min read
How to Tune JVM for 1M Daily Logins on an 8 GB Server
Amazon Cloud Developers
Amazon Cloud Developers
Oct 13, 2025 · Artificial Intelligence

Agentic AI Guide: Building and Deploying Robust AI Agents

This article provides a comprehensive technical guide on Agentic AI, detailing the core modules, infrastructure requirements, security considerations, observability practices, and deployment strategies needed to develop and operate production‑ready AI agents.

AI AgentsAgentOpsAgentic AI
0 likes · 27 min read
Agentic AI Guide: Building and Deploying Robust AI Agents
Ma Wei Says
Ma Wei Says
Oct 2, 2025 · Databases

Essential Redis Best Practices: Keys, Memory, Security, and Performance

This guide outlines practical Redis best‑practice rules covering key naming conventions, data‑size limits, expiration strategies, script and transaction usage, client connection handling, and security measures to help you build fast, stable, and secure production systems.

Key DesignMemory ManagementRedis
0 likes · 9 min read
Essential Redis Best Practices: Keys, Memory, Security, and Performance
IT Services Circle
IT Services Circle
Oct 2, 2025 · Backend Development

Cracking Baidu's C++/PHP Interview: Key Questions, Answers, and QuickSort Code

This article examines the diminishing premium of overseas degrees, suggests one‑year master programs for career advancement, and then provides a comprehensive Baidu interview guide covering C++/PHP fundamentals, memory allocation, networking protocols, process vs thread, Redis performance, and a complete quicksort implementation in C++.

C#Memory ManagementQuickSort
0 likes · 13 min read
Cracking Baidu's C++/PHP Interview: Key Questions, Answers, and QuickSort Code
Ops Community
Ops Community
Oct 1, 2025 · Databases

Why Did Redis Memory Spike 10×? Uncover the Hidden Config Mistake

A sudden Redis memory surge from 2 GB to 20 GB was traced to a misconfigured list-compress-depth parameter, revealing how uncompressed lists and queue backlogs can cause ten‑fold memory growth, and outlining step‑by‑step diagnostics, compression fixes, and long‑term optimization strategies.

ConfigurationList CompressionMemory Management
0 likes · 24 min read
Why Did Redis Memory Spike 10×? Uncover the Hidden Config Mistake
Python Programming Learning Circle
Python Programming Learning Circle
Sep 30, 2025 · Fundamentals

How to Supercharge Your Python Code: Proven Performance Optimization Techniques

This comprehensive guide walks you through Python performance optimization, covering profiling, algorithmic improvements, data‑structure choices, code‑level tricks, concurrency, memory management, third‑party libraries and a practical checklist to ensure your programs run faster and more efficiently.

Memory ManagementPerformance OptimizationProfiling
0 likes · 18 min read
How to Supercharge Your Python Code: Proven Performance Optimization Techniques
Python Crawling & Data Mining
Python Crawling & Data Mining
Sep 30, 2025 · Fundamentals

Unlock Python’s Memory Secrets: Advanced Techniques to Boost Performance

This comprehensive guide explores Python’s memory management internals, covering allocation, reference counting, garbage collection, profiling tools, optimization strategies such as slots, generators, array usage, memory views, custom allocators, and practical case studies for big data and web applications, helping developers write faster, more memory‑efficient code.

Garbage CollectionMemory ManagementPython
0 likes · 24 min read
Unlock Python’s Memory Secrets: Advanced Techniques to Boost Performance
Programmer XiaoFu
Programmer XiaoFu
Sep 25, 2025 · Databases

Redis LRU vs Classic LRU: Differences, LFU Comparison, and How to Choose

Redis implements an approximate LRU using random sampling and timestamps, while classic LRU relies on exact access order; the article explains both LRU and LFU fundamentals, their Java implementations, Redis-specific variants, trade‑offs, use‑case recommendations, and configuration tips for selecting the optimal eviction policy.

Cache EvictionJavaLFU
0 likes · 21 min read
Redis LRU vs Classic LRU: Differences, LFU Comparison, and How to Choose
Python Programming Learning Circle
Python Programming Learning Circle
Sep 23, 2025 · Fundamentals

Master Python Shallow vs Deep Copy: Avoid Hidden Bugs and Boost Your Code

This article explains the difference between shallow and deep copying in Python, shows why simple copies can unintentionally modify original data, provides visual memory diagrams, demonstrates multiple copying methods with code examples, compares performance, and offers practical guidelines for choosing the right copy technique in real projects.

Memory ManagementPythoncopy module
0 likes · 10 min read
Master Python Shallow vs Deep Copy: Avoid Hidden Bugs and Boost Your Code
Deepin Linux
Deepin Linux
Sep 23, 2025 · Fundamentals

Mastering Linux Memory Allocation: When to Use brk vs mmap

This article explains the low‑level mechanisms of brk and mmap in Linux, compares their characteristics, shows why malloc selects one over the other based on allocation size, and provides practical code examples, performance tips, and common pitfalls for developers.

LinuxMemory ManagementPerformance Optimization
0 likes · 29 min read
Mastering Linux Memory Allocation: When to Use brk vs mmap
Deepin Linux
Deepin Linux
Sep 21, 2025 · Fundamentals

Why Linux Uses Copy‑On‑Write: Boosting Process Creation and Memory Efficiency

This article explains Linux’s Copy‑On‑Write mechanism, detailing how it avoids full memory duplication during process creation, the underlying page‑table workflow, its implementation in the kernel, and real‑world applications such as Redis persistence, Docker image layering, and filesystem snapshots, while also discussing its advantages and drawbacks.

Copy-on-WriteLinuxMemory Management
0 likes · 73 min read
Why Linux Uses Copy‑On‑Write: Boosting Process Creation and Memory Efficiency
DevOps Coach
DevOps Coach
Sep 20, 2025 · Cloud Native

Why a Tiny Memory‑Intensive Process Caused 100× Latency Spikes After Pinterest’s Search Migration to Kubernetes

During Pinterest’s migration of its high‑traffic Manas search platform to the PinCompute Kubernetes environment, engineers observed an extremely rare latency outlier—one in a million requests took 100 times longer—prompting a deep investigation that traced the root cause to cAdvisor’s memory‑intensive smaps scans interfering with leaf node processing.

Cloud NativeMemory ManagementPerformance debugging
0 likes · 14 min read
Why a Tiny Memory‑Intensive Process Caused 100× Latency Spikes After Pinterest’s Search Migration to Kubernetes
MaGe Linux Operations
MaGe Linux Operations
Sep 20, 2025 · Databases

Master Redis Memory Troubleshooting: From Basics to Advanced Solutions

This comprehensive guide walks you through diagnosing and resolving Redis memory issues, covering the underlying architecture, common pitfalls such as memory leaks and fragmentation, practical diagnostic commands, automated monitoring scripts, and optimization techniques to prevent costly outages and improve performance.

Memory ManagementPerformance OptimizationRedis
0 likes · 26 min read
Master Redis Memory Troubleshooting: From Basics to Advanced Solutions
Deepin Linux
Deepin Linux
Sep 20, 2025 · Fundamentals

How Linux Handles Page Faults: Inside Virtual Memory Management

This article explains Linux page faults, describing how the kernel intercepts invalid or unmapped memory accesses, the step‑by‑step handling process, the four typical fault scenarios, and optimization techniques, while providing code examples and diagrams to illustrate virtual‑memory management in depth.

LinuxMemory ManagementPage Fault
0 likes · 41 min read
How Linux Handles Page Faults: Inside Virtual Memory Management
Deepin Linux
Deepin Linux
Sep 19, 2025 · Fundamentals

Unlocking Linux Memory: How Virtual Memory, MMU, and Heap Really Work

This article demystifies Linux process memory by explaining the layered architecture of virtual and physical memory, the role of the MMU and page tables, dynamic allocation mechanisms such as brk and mmap, and practical tools for inspecting and optimizing memory usage.

LinuxMMUMemory Management
0 likes · 47 min read
Unlocking Linux Memory: How Virtual Memory, MMU, and Heap Really Work
Deepin Linux
Deepin Linux
Sep 18, 2025 · Fundamentals

How Linux’s Buddy Allocator Powers Efficient Memory Management

This article explains the Linux kernel’s buddy memory allocation algorithm, covering its core principles, data structures, allocation and free workflows, performance advantages and drawbacks, monitoring tools, tuning parameters, and real‑world use cases such as Kubernetes, embedded IoT devices, and real‑time operating systems.

LinuxMemory Managementbuddy allocator
0 likes · 50 min read
How Linux’s Buddy Allocator Powers Efficient Memory Management
AndroidPub
AndroidPub
Sep 15, 2025 · Mobile Development

Why Android 15’s Switch to 16KB Memory Pages Matters for Your App

Google’s shift to 16KB memory pages in Android 15, mandatory for Play Store submissions after November 1 2025, brings performance gains, reduces TLB misses, and forces native‑code developers to update build flags and eliminate hard‑coded 4KB assumptions to stay compliant.

AndroidMemory ManagementNDK
0 likes · 8 min read
Why Android 15’s Switch to 16KB Memory Pages Matters for Your App
Deepin Linux
Deepin Linux
Sep 11, 2025 · Fundamentals

Mastering C++ Smart Pointers: unique_ptr, shared_ptr, and weak_ptr Explained

This article introduces C++ smart pointers—unique_ptr, shared_ptr, and weak_ptr—explaining their RAII‑based automatic memory management, usage patterns, performance considerations, common pitfalls such as cyclic references, and practical examples including factory patterns and GUI data sharing, while also covering size and custom deleters.

C#Memory Managementshared_ptr
0 likes · 24 min read
Mastering C++ Smart Pointers: unique_ptr, shared_ptr, and weak_ptr Explained
Deepin Linux
Deepin Linux
Sep 11, 2025 · Fundamentals

Mastering C++ Memory: When to Use new/delete vs malloc/free

This article explains the fundamental differences between C's malloc/free and C++'s new/delete, covering their underlying mechanisms, proper usage patterns, common pitfalls, error‑handling strategies, and best‑practice recommendations such as smart pointers and memory‑pool techniques.

C#Memory Managementmalloc
0 likes · 29 min read
Mastering C++ Memory: When to Use new/delete vs malloc/free
Liangxu Linux
Liangxu Linux
Sep 6, 2025 · Fundamentals

13 Typical C Segmentation Fault Cases Every Programmer Should Know

This guide enumerates thirteen classic C segmentation fault patterns—including null pointer dereference, illegal memory access, stack overflow, buffer overrun, and misuse of dynamic memory—provides concise code examples for each, explains the underlying cause, and offers practical tips to prevent such crashes.

C#Memory ManagementPointers
0 likes · 9 min read
13 Typical C Segmentation Fault Cases Every Programmer Should Know
Linux Kernel Journey
Linux Kernel Journey
Sep 6, 2025 · Fundamentals

From xarray to Swap Table: Streamlining Linux Swapcache Management

The article analyzes how the newly introduced swap table replaces the kernel's xarray for swapcache, offering O(1) lookups, better locality, reduced lock contention, and lower memory overhead, with benchmark results showing notable performance gains in real workloads.

Linux kernelMemory Managementswap table
0 likes · 11 min read
From xarray to Swap Table: Streamlining Linux Swapcache Management
Instant Consumer Technology Team
Instant Consumer Technology Team
Sep 5, 2025 · Artificial Intelligence

Why Context Engineering Is the Next Frontier for Large Language Models

This article surveys over 1,400 papers to define context engineering as a systematic discipline that structures retrieval, memory, tools, and multi‑agent coordination for LLMs, highlighting the critical asymmetry between understanding long contexts and generating equally complex outputs.

LLM evaluationMemory ManagementRetrieval-Augmented Generation
0 likes · 8 min read
Why Context Engineering Is the Next Frontier for Large Language Models
Alibaba Cloud Developer
Alibaba Cloud Developer
Sep 4, 2025 · Artificial Intelligence

Why Context Engineering Is the New Frontier in LLM Development

This article explores the rise of Context Engineering as an essential discipline for large language models, comparing it to Prompt Engineering, detailing its definition, classifications, common pitfalls such as poisoning and distraction, and presenting best‑practice strategies and an LLM‑OS analogy for building robust AI agents.

LLMLLM OSMemory Management
0 likes · 27 min read
Why Context Engineering Is the New Frontier in LLM Development
Tencent Technical Engineering
Tencent Technical Engineering
Sep 1, 2025 · Backend Development

Mastering Go Garbage Collection: Tips to Slash Latency and Boost Performance

This article explains Go's memory management mechanisms—including GC fundamentals, stop‑the‑world marking, tri‑color marking with write barriers, hybrid write barriers, and practical optimization techniques such as reducing heap allocations, using caches, concurrency patterns, and profiling tools—to help developers identify and eliminate performance bottlenecks.

Garbage CollectionGoMemory Management
0 likes · 20 min read
Mastering Go Garbage Collection: Tips to Slash Latency and Boost Performance
IT Services Circle
IT Services Circle
Aug 31, 2025 · Fundamentals

How the New Linux Swap Table Boosts Performance by Up to 20%

A recent Linux kernel patch introduces a unified Swap Table architecture that integrates swap cache, mapping, and allocation, delivering 5%‑20% overall speedups, up to 20% gains in VM scalability, faster builds, and higher Redis/Valkey throughput while reducing memory usage.

LinuxMemory Managementkernel
0 likes · 3 min read
How the New Linux Swap Table Boosts Performance by Up to 20%
Liangxu Linux
Liangxu Linux
Aug 27, 2025 · Fundamentals

Master C Pointers: Definition, Usage, and Practical Examples

This article explains what pointers are in the C language, how to define and use them, common scenarios such as dynamic memory allocation and array handling, and provides a complete, annotated example that demonstrates accessing and modifying variable values through pointers.

C#FundamentalsMemory Management
0 likes · 4 min read
Master C Pointers: Definition, Usage, and Practical Examples
Liangxu Linux
Liangxu Linux
Aug 26, 2025 · Fundamentals

17 Common C Segmentation Fault Pitfalls and How to Avoid Them

This article walks through seventeen classic C programming mistakes that cause segmentation faults—such as null pointers, out‑of‑bounds array access, wild pointers, double frees, and format string bugs—and provides safe, production‑ready code examples to prevent each crash.

C#Memory ManagementPointers
0 likes · 18 min read
17 Common C Segmentation Fault Pitfalls and How to Avoid Them
Deepin Linux
Deepin Linux
Aug 24, 2025 · Fundamentals

Why Is Stack Memory Faster Than Heap? A Deep Dive into Stack vs. Heap Allocation

This article explains the fundamental differences between stack and heap memory allocation, covering their allocation mechanisms, performance characteristics, common pitfalls such as stack overflow and memory leaks, practical code examples in C/C++, and typical interview questions to help developers choose the right memory model for their applications.

C#Memory Managementallocation
0 likes · 65 min read
Why Is Stack Memory Faster Than Heap? A Deep Dive into Stack vs. Heap Allocation
Deepin Linux
Deepin Linux
Aug 23, 2025 · Fundamentals

How Does delete Know Memory Size? A Deep Dive into C++ Memory Management

This article explains C++ memory management fundamentals, detailing how delete and free release memory without explicit size knowledge, the role of stack, heap, data and code segments, differences between new/delete and malloc/free, array handling, common pitfalls, and interview questions with code examples.

C#FreeMemory Management
0 likes · 34 min read
How Does delete Know Memory Size? A Deep Dive into C++ Memory Management
Full-Stack DevOps & Kubernetes
Full-Stack DevOps & Kubernetes
Aug 19, 2025 · Operations

Boost Linux Server Performance: Proven Optimization Techniques for CPU, Memory, Disk, and Network

Learn how to dramatically improve Linux server efficiency by addressing common resource bottlenecks with modern CPU scheduling, memory management, I/O scheduler selection, network tuning, and practical diagnostic tools, while also exploring emerging AI‑assisted optimization trends for future‑proof performance.

I/O TuningLinuxMemory Management
0 likes · 7 min read
Boost Linux Server Performance: Proven Optimization Techniques for CPU, Memory, Disk, and Network
Tencent TDS Service
Tencent TDS Service
Aug 18, 2025 · Mobile Development

How to Adapt Your Android App for the New 16KB Page Size Requirement

Starting November 1, 2025, Google Play will require Android apps to support 16KB memory pages, so developers must align native libraries, adjust hard‑coded page size assumptions, verify .so alignment with provided scripts, and choose the appropriate Bugly SDK version to ensure compliance and avoid crashes.

16KB page sizeAndroidBugly
0 likes · 7 min read
How to Adapt Your Android App for the New 16KB Page Size Requirement
Instant Consumer Technology Team
Instant Consumer Technology Team
Aug 15, 2025 · Artificial Intelligence

Why Building Enterprise AI Agents Feels Like Building a Distributed Brain

An engineer recounts the hard‑earned lessons from moving beyond RAG to enterprise‑level AI agents, exposing three critical challenges—scheduling, memory management, and tool integration—and proposes architectural patterns that turn fragile prototypes into robust, observable, and secure AI systems.

AI AgentsAgentic EngineeringEnterprise AI
0 likes · 9 min read
Why Building Enterprise AI Agents Feels Like Building a Distributed Brain