Forem: memU

$3,000 Prize Pool · Global Online Hackathon · Agent Infrastructure Tech Stack

memU — Fri, 09 Jan 2026 13:32:53 +0000

Event Title

2026 New Year Challenge - 5 Projects United Hackathon

Event Theme

The 2026 New Year Challenge is a global, collaborative hackathon jointly hosted by five leading AI projects. Running for 10 days, from Jan 8 to Jan 18, 2026 (PT), the event offers a total prize pool of $3,000.

Each project hosts its own independent track, covering diverse aspects of modern AI agent development, from memory management and automation to external integrations and deployment.

You can participate in multiple tracks simultaneously, and each track will be evaluated separately based on its own scoring.

Registration opens on Jan 8 at 00:00 PT. https://memu.pro/hackathon

Participants are welcome to join the event community in advance. https://discord.gg/KBMK8aEFkm

Organizers

MemU · OpenAgents · Sealos · TEN Framework · Zeabur

Event Timeline

One shared timeline for all challenges

Build Period

Jan 8, 00:00 PT — Hackathon starts

Jan 18, 00:00 PT — PR and project submissions close

Jan 22 — Winners announced & payouts

After the Build Review, judging, and result announcements follow after the build period.

All five project challenges run within this shared timeframe.

While the timeline is shared, each project runs its own judging and reward system.

Rewards & Scoring

Independent rewards for each project

Each project challenge defines its own:

Reward structure

Scoring or evaluation system

Winner selection process

There is no global leaderboard across all five projects.

Your performance is evaluated only within the project challenges you join.

👉 See each project’s challenge page for detailed rules and rewards.

Challenge Tracks Overview

Five projects. Five challenges. Build in parallel.

🧠 MemU PR Hackathon

$600 prize pool · Community badge · MemU credits

Build the memory layer for next-gen AI agents.

Join a 10-day open-source PR hackathon and ship real contributions to MemU.

Fix bugs, add features, build integrations and contributor guides — every merged PR earns points, recognition, and lasting credit in the project.

🌟 Star MemU on GitHub: https://github.com/NevaMind-AI/memU

🛜 OpenAgents PR Hackathon

$500 prize pool · Community badge

AI Agent Networks for Open Collaboration.

Join a 10-day open-source hackathon and ship real usecase contributions to OpenAgents.

We sincerely invite developers to build a practical, interesting and innovative Agent Network based on the OpenAgents platform, solve real-world problems with technology, and spark brand-new inspiration for innovation!

🌟 Star OpenAgents on GitHub:https://github.com/openagents-org/openagents

🧩 Sealos Run Wild Hackathon

Unlimited participation

Ready to ship? The Sealos Run Wild Hackathon is an online sprint for creators who want to see their apps alive. From Jan 8 to Jan 18, we are removing all limits. No PRs required. No complex tech stack restrictions.

You have two missions to choose from:

The Open Deployment Challenge: Deploy anything (games, tools, blogs) on Sealos.

The memU Integration Track: Build smart agents using memU and Sealos Devbox. Just chat with the Sealos desktop to deploy in seconds, and submit your Live Demo URL. We value finished products over prototypes. Winners get traffic, resources, and the spotlight they deserve.

🌟 Star Sealos on GitHub: https://github.com/labring/sealos

🎙️ TEN Framework PR Hackathon

$600 prize pool

Join a 10-day open-source PR hackathon and ship real contributions to TEN Framework.

Fix bugs, add extensions, xxxx and contribute docs — every merged PR earns points, recognition, and lasting credit in the project.

🌟 Star TEN Framework on GitHub: https://github.com/TEN-framework/ten-framework

🏋️ Zeabur Ship It Hackathon

$600 prize pool · Community badge

The Zeabur Ship It Hackathon is a 10-day global open-source challenge designed for builders who want to move fast.
Transform a raw idea into a fully deployed, production-ready application.

By using Zeabur AI Hub, an API for different AI models or using one-click deployment, you can take your project live on a zeabur.app domain in seconds.

To kickstart your journey, every participant using Zeabur AI Hub in their projects receives $5 credits.

🌟Star Zeabur on GitHub: https://github.com/zeabur/zeabur

We look forward to your participation.

The event organizers reserve the right to final interpretation.

A file-based agent memory framework

memU — Thu, 08 Jan 2026 03:28:03 +0000

Hi everyone, we've open-sourced a file-based agent memory framework called memU.
If you find it interesting, a GitHub star⭐️ would be much appreciated🙏 : GitHub link

Andrej Karpathy, a member of OpenAI’s founding team, expressed agreement with the view that “RAG is dead.”
So we built a memory framework that retrieves knowledge through LLM-based file reading.

memU's Core ideas:

Dual-mode retrieval: embedding + non-embedding search Non-embedding search is designed to compensate for the structural accuracy limitations of traditional RAG in high-precision scenarios.
Memory as readable Markdown files, not opaque vectors At the Category layer, memory is stored as human-readable Markdown files. This follows the same underlying design philosophy as Anthropic's skills.md.
Designed to plug directly into real production agents, with fully configurable prompts For example, an engineering agent can persist its core knowledge as Service_Architecture.md and Incident_Playbooks.md. The model reads these structured files first to establish correct reasoning premises, avoiding drift caused by "similar but incorrect" retrieval results.

Anyone interested is welcome to try it out and explore the code.😺

memU 1.0.0: Memory-Driven Agent Evolution

memU — Mon, 05 Jan 2026 15:24:19 +0000

Original link：https://memu.pro/blog/memu-1-0-0-release

memU has been open-sourced for nearly five months.

During this time, with strong support from the community and real-world users, we’ve gained substantial hands-on experience and deeper insights into what agent memory systems actually need to work in practice.

As more teams build increasingly complex agents, one thing has become clear: the demand for persistent, inspectable, and evolvable agent memory is growing rapidly — and most existing solutions fall short in real-world use.

With the new year kicking off, memU 1.0.0 is here. If you like what you see, a star on GitHub would mean a lot to us: https://github.com/NevaMind-AI/memU

This release is not only an upgrade to the system itself, but also a refinement of our direction. We listened closely to the feedback from developers and users, and shaped memU 1.0.0 around the real problems people face when building agents.

Our conclusion is straightforward:

memU 1.0.0 is a memory infrastructure built specifically for agents — evolvable, maintainable, and designed for long-term use.

It is not about larger context windows, nor about more complex RAG pipelines.

Instead, memU provides a long-term memory system that humans can manage, agents can understand, and agent capabilities can evolve over time.

From our perspective, a limited context window should be filled with distilled, retrieved, and precisely matched memory — not raw information stacked end to end.

Three-Layer Memory Architecture

In memU 1.0.0, we design a simple yet scalable three-layer memory architecture.

The design is inspired by layered storage systems in computer science: through step-by-step abstraction, messy and diverse data is turned into memory that an agent can understand, retrieve, and evolve over time.

The overall flow is: Resource Layer → Memory Item Layer → Memory Category Layer

Resource Layer. This is the raw data layer. It stores original multi-modal resources such as text, files, logs, conversations, code, images, and more. The focus here is completeness and traceability. No early abstraction is applied.

Memory Item Layer. This layer extracts discrete memory units from raw resources. Each memory item is the smallest meaningful unit that can be understood and referenced on its own. These items form the foundation for agent reasoning and retrieval.

Memory Category Layer (Memory Files). This is the aggregation layer. Multiple Memory Items are organized and merged into structured text memory files. Only these aggregated memory files are finally sent into the Agent’s context and used for decision-making and reasoning.

A Self-Evolving Memory Retrieval Loop

With this architecture, memory storage, organization, and retrieval are not isolated steps. They form a complete feedback loop across the three layers.

When new information enters the system, it is first stored in the Resource Layer in its original form.

From there, the system gradually extracts Memory Items with clear meaning and places them into appropriate Memory Category files based on the existing memory structure.

As memory moves upward, meaning becomes clearer and structure becomes more stable.

At the organization level, a Memory Category is not just a standalone file.

Different category files can reference or share Memory Items, forming connections that better reflect real-world task knowledge, rather than rigid and isolated classifications.

When an Agent performs a task, retrieval happens top-down.

The system retrieves memory at the Memory Category layer first. Each category corresponds to a complete aggregated memory file, and the entire retrieved file is injected into the context window.
When a memory has not been referenced for a long time, it may no longer appear at the category layer and is effectively “forgotten” at that level. In this case, the system falls back to retrieve from deeper layers. If the memory item is still not found, the original resource is always retrievable, since resources are never pruned or discarded.

This process does not rely on manually tweaking rules again and again.

Instead, continuous feedback from real usage allows the memory structure to gradually align with how the Agent actually works.
Through this cycle of store → retrieve → evolve, memory is no longer a static archive. It becomes a system that can correct itself and evolve, continuously supporting the Agent’s growth.

Two Retrieval Methods: LLM-Based and RAG

Built on top of this architecture, memU 1.0.0 provides two complementary memory retrieval methods:

LLM-based retrieval
The model directly reads memory files and original resources, enabling deep semantic understanding and reasoning.
RAG-based retrieval
Fast vector embedding search, designed for high-performance and low-latency scenarios.

In memU’s design, RAG is an efficient baseline capability. However, for complex tasks, we recommend LLM-based deep retrieval.
Vector similarity retrieval is effective for surface-level relevance, but often fails to capture deeper semantics, structure, and relationships within memory files.

By allowing the LLM to directly “read” memory files, memU enables Agents to do more than just find memories — they can truly understand and use them.

Multi-Modal Support: Unified as Text Memory for Agents

memU’s three-layer architecture natively supports multi-modal data at the lowest level.

Text, code, logs, images, and other unstructured data are all ingested into the Resource Layer in their original form, fully preserved and traceable.

During later processing, this multi-modal data is gradually transformed into readable text memories and enters the Memory Item and Memory Category layers.

This is not a loss of multi-modal capability, but a deliberate engineering choice.

On one hand, today’s large models are strongest at understanding, reasoning, and generating text.

Unifying different modalities into text makes memory usage more stable during reasoning and decision-making.

On the other hand, a unified text format allows memory organization at higher layers to stay consistent.

Memory Category files can share the same structure without maintaining parallel systems for different modalities.

By preserving raw multi-modal data at the bottom, unifying memory as text at higher layers, and combining this with self-evolving retrieval and LLM-based reading, memU strikes a balance between completeness, clarity, and engineering simplicity.

This allows Agents to rely on a single, stable memory structure while learning from long-term experience across different modalities.

The memU Ecosystem Is Now Available

Alongside the core upgrade in memU 1.0.0, we have also open-sourced and released memU-server and memU-ui, completing the path from algorithms to real-world deployment.

memU: The core algorithm engine. It provides memory extraction, organization, and multi-strategy retrieval. memU can be used on its own or embedded into existing Agents or applications as the memory algorithm layer.
memU-server: A self-hosted backend service for memory data management. It supports full Memory CRUD operations, retrieval tracking, token usage and billing stats, user systems, RBAC permissions, and security boundaries. It is well suited for internal tools, research setups, and enterprise deployments.
memU-ui: A front-end dashboard designed to work with memU and memU-server. It offers visual memory browsing, data retrieval interfaces, and user management tools, making self-hosting and daily operations much easier for teams.

By combining memU, memU-server, and memU-ui, developers can either use only the core algorithms or quickly deploy a complete, self-hosted, and manageable Agent memory system.

This makes long-term memory a practical, maintainable part of real production systems.

Workflow Support and Task Execution Context

This release enhances memU’s built-in workflow support across the algorithm layer, backend, and frontend.

Tasks can be modeled as workflows with ordered steps.

At each step, memory can be written, updated, and retrieved in context, allowing memory to evolve alongside task execution rather than being stored as a flat final result.

Workflow support also allows prompts to be modified and highly customized per scenario, making it easier to adapt Agent behavior to different task structures and execution needs.

Each workflow maintains detailed execution logs, enabling developers to understand how a task progresses, inspect what happens at each step, and debug complex or long-running workflows more effectively.

Memory files can be associated with specific workflow steps and execution moments, supporting step-based inspection and clearer temporal understanding of how memory is produced and used.

By integrating workflows end to end, memU brings memory, execution context, and Agent behavior into a single structured process, instead of treating them as separate systems stitched together.

User Model and User Context Awareness

In the new version, memU now supports clear separation of user models and user context.

Developers can define different user models for different users, and memU keeps memory writing and retrieval strictly scoped to the current user.

This prevents memory from leaking across users and ensures that Agents respond using the correct personal history.

When memory is written, memU records which user it belongs to.
When memory is retrieved, the system always checks the active user context before returning results.

This is essential for multi-user products such as assistants, copilots, and internal tools, where memory must stay personal, predictable, and safe.

By handling user context explicitly, memU makes personalized long-term memory easier to reason about and easier to operate as the system grows.

Database Storage and Schema Evolution

This version improves memU’s database-backed storage for memory data, making it more robust for long-lived Agent systems.

memU uses PostgreSQL as its primary storage backend, with optional pgvector support for vector search.

Memory data is organized into structured tables covering resources, memory items, memory files, and their relationships, enabling clearer inspection and management.

A new internal schema evolution mechanism has been introduced.
As memU continues to add features and refine its memory model, the package now maintains its own upgrade strategy to ensure that existing memory data remains compatible across versions.

This makes version upgrades safer and more predictable, while allowing application developers to handle their own data transformations when needed.

With a more reliable storage layer and controlled internal upgrades, memU can now better support continuous iteration and production-scale Agent workflows.

Looking Ahead

memU 1.0.0 is not an endpoint — it is a new starting point.

What matters to us is not how much memory can be stored, but whether memory is truly used, understood, and shaped by real Agent work.

Going forward, we will continue refining memory structure, retrieval methods, and system boundaries based on real Agent scenarios.

Our goal is to make long-term memory a reliable foundation that every Agent can depend on.

If you are struggling with memory selection, organization, or evolution while building Agents, feel free to reach out.

We would love to hear about real memory challenges from real use cases.

You can find more about MemU on:
GitHub (⭐️ Star us): https://github.com/NevaMind-AI/memU
Official website: https://memu.pro
Discord: https://discord.gg/memu
X: https://x.com/memU_ai
Medium: https://medium.com/@memU_ai
YouTube: https://www.youtube.com/channel/UCv4ivxu9RImsTBkIwnE59uw
✉️Email: contact@nevamind.ai

MemU: Let AI Truly Memorize You

memU — Sat, 09 Aug 2025 12:57:16 +0000

Current AI memory solutions face scalability challenges. They rely on explicit modeling — manually telling the system which memories matter and which don’t. This approach fundamentally limits the AI’s ability to truly understand what’s important to you and memorize what matters most.

Moreover, existing solutions take a one-fits-all approach, applying the same memory mechanisms across all use cases. We’re taking a different path by specializing in AI companion scenarios, optimizing every aspect of memory specifically for meaningful, long-term relationships between humans and AI.

That’s where MemU comes in.

MemU is a next-generation open-source memory framework designed for AI agents that need to remember, adapt, and grow with users over time. It provides a full-stack memory infrastructure optimized for persistent, structured, and evolving knowledge across interactions.

What is MemU?

MemU provides an intelligent memory layer for AI agents. It treats memory as a hierarchical file system: one where entries can be written, connected, revised, and prioritized automatically over time. At the core of MemU is a dedicated memory agent. It receives conversational input, documents, user behaviors, and multimodal context, converts structured memory files and updates existing memory files.

Core Capabilities:

Memory as a file system

All user interactions are processed through a memory agent that indexes, categorizes, and transforms content into structured memory documents. There is no need for developers to hand-design schemas or memory slots — the system adapts based on content and context.

Linking and Graph Construction

MemU treats each memory as part of a larger knowledge graph. It automatically detects connections across time and modality, building a dynamic web of related experiences that can be queried and traversed like a hyperlinked document system.

Self-Reflection and Evolution

During offline, the background memory agent performs analysis to refine and consolidate memory clusters. This process mirrors human reflection: it merges redundant information, summarizes topics, fills knowledge gaps, and infers implicit relationships between seemingly unconnected experiences.

Contextual Retention and Forgetting

Not all memories are equally important. MemU continuously reprioritizes memory items based on usage patterns and retrieval contexts. This enables adaptive memory retention and graceful forgetting — similar to how humans maintain relevance without overwhelming cognitive load.

Why Use MemU?

Most memory systems in today’s LLM pipelines are either too rigid, too shallow, or too manual. MemU offers a flexible, robust alternative that brings true memory to the agent layer.

Modular Architecture

Designed as a standalone memory layer, MemU can be plugged into any LLM pipeline or multi-agent system. It provides clean interfaces for both memory ingestion and retrieval, and supports asynchronous background processing for offline learning and consolidation.

High Memory Accuracy

MemU achieves 92% accuracy on the Locomo benchmark across memory-intensive reasoning tasks. This performance is achieved through its hybrid retrieval engine, which combines semantic, keyword-based, and contextual retrieval techniques.

Human-Readable Memory Format

Unlike memory buffers or embedding stores, MemU organizes memories as coherent, readable documents. This enables debugging, manual editing, memory introspection, and real-time analytics.

Cost and Latency Optimized

MemU is engineered to be efficient at scale. It delivers up to 90% cost savings compared to conventional cloud-based memory chains through optimization in storage, retrieval, and indexing.

Flexible Deployment Modes

Cloud Version: Fastest way to integrate with hosted APIs and managed infrastructure
Self-hosted (Coming Soon): For privacy-sensitive applications or air-gapped systems
Enterprise Edition: Includes SLA, white-labeling, advanced security, and team-level analytics

What Can You Build with MemU?

MemU serves as a foundational layer for LLM-based applications that require persistent context and long-term understanding. It is optimized for a range of use cases:

Long-term AI Assistants
Equip personal AI agents with the ability to recall past meetings, preferences, goals, and user behavior patterns. Enable task automation that is context-aware and personalized over time.
Persistent IP Characters and AI Companions
Build AI personas that remember individual users, shared stories, inside jokes, emotional events, and role-play history — allowing them to evolve their character and personality over repeated interactions.
Narrative-Aware Roleplay Systems
Use MemU to drive AI-driven storytelling engines where memory affects world state. NPCs recall past encounters, quests have lasting consequences, and character relationships evolve organically.
Adaptive Education and Tutoring
Retain knowledge of student progress, learning styles, and historical misunderstandings. Deliver personalized instruction that builds on past sessions rather than repeating static content.
Mental Health and Emotional Support
Maintain continuity across sessions by tracking emotional history, user challenges, coping mechanisms, and therapy outcomes. Provide empathetic, context-aware wellness support.
Creative Co-Pilots for Content Generation
Remember past drafts, stylistic preferences, visual inspirations, or brand tone. Collaborate with users across long-form writing, design workflows, or serial creative projects.

With MemU, memory shifts from a missing piece to a driving force

Explore the MemU repository and start building agents that remember, adapt, and grow. If you enjoy building with MemU or exploring what’s possible, we’d appreciate it if you could star the repo HERE

Visit Official website to get started, explore the docs, and follow new releases. Have questions, feedback, or ideas? Join our Discord community and be part of shaping the future of memory-powered AI.

You can find more about MemU on:

Official website: https://memu.pro

Discord: https://discord.gg/memu

X: https://x.com/memU_ai

Medium: https://medium.com/@memU_ai

YouTube: https://www.youtube.com/channel/UCv4ivxu9RImsTBkIwnE59uw

✉️Email: contact@nevamind.ai