# Membria Local Client

Membria's mission is to build a decentralized, self-sustaining, and permanent knowledge base—a 'Wikipedia for Small Language Models (SLMs)'. The goal of this tokenomic model is to construct a sustainable economy that incentivizes the creation of high-quality knowledge, rewards network participants, and ensures the long-term value growth of the ecosystem.

A revolution is happening right now. Millions of developers, researchers, and enthusiasts are downloading open-source language models like Llama 3, Phi-3, and Mistral from Hugging Face. For the first time, people can run powerful AI directly on their own computers, with complete privacy and at no cost. The initial experience is thrilling: "I have my own GPT running on my laptop!"

But after a few days of use, that excitement often gives way to disappointment. Users hit a fundamental "wall of limitations" that turns their powerful AI into a clever but static toy.

• The "Static Brain" Problem: The model you download is brilliant, but its knowledge is frozen at the moment its training ended (e.g., early 2023). It knows nothing about new technologies, recent events, or the latest version of your favorite framework. It quickly becomes obsolete.
• The "Amnesia" Problem: The local model knows nothing about you. Every new conversation starts from a blank slate. It doesn't remember your previous questions, your projects, your writing style, or your goals. It's a powerful tool, but it's not a personal assistant.
• The "Generalist Trap": A base model is a generalist. To make it an expert in a niche field (like law or medicine), you need to perform complex and expensive fine-tuning with LoRA adapters, which is an insurmountable barrier for most users.
• The "Information Silo" Problem: The model operates in a vacuum, cut off from your own knowledge base—your PDFs, documents, notes, and emails. Making that data accessible requires building a complex RAG system from scratch.

The Membria Client is the operating system that demolishes this "wall of limitations," transforming a static model into a living, constantly evolving partner. This approach aligns with a pragmatic view where complex goals are decomposed into modular sub-tasks, each of which can be reliably handled by specialized and efficient models.

• Solving the "Static Brain" -> A Living Brain: When a local model doesn't know an answer, Membria's CAG (Cache-Augmented Generation) mechanism seamlessly queries the global, constantly updated Knowledge Graph. Your model trained in 2023 can now operate with facts from today.
• Solving "Amnesia" -> A Personal Memory: Membria's local database architecture (SQLite + DuckDB) becomes your AI's long-term memory. Its agents can privately index your local files, creating a rich personal context. The AI begins to understand your projects and remember your preferences.
• Solving the "Generalist Trap" -> The Instant Specialist: SkillForge makes the complex process of applying LoRA patches as simple as installing a browser extension. With a single click, you can turn your generalist AI into a "Python expert" or a "financial analyst."
• Solving the "Information Silo" -> The Integrated Workspace: With built-in RAG and autonomous agents, the AI is no longer an external program but an active participant in your work. It can independently analyze folders of documents, prepare summaries, and use your data in its responses.

Membria is the missing piece that transforms the current hype around local models into a real, productive tool. It elevates local AI from an "interesting tech demo" to an "indispensable daily assistant" that constantly learns, adapts, and grows smarter with you.

The Membria Client is a cross-platform application (Windows, macOS, Linux) that serves as the user's personal AI hub. Its primary mission is to provide powerful, personalized, and private AI capabilities that run directly on the user's device, with the ability to seamlessly augment its knowledge from the decentralized Membria network. The client is designed as a modular system, giving the user full control over their AI models, skills, and data.

The client's architecture consists of four interconnected components:

1. AI Core: Responsible for running and managing local language models.
2. SkillForge: A manager for dynamically attaching "skills" (LoRA patches).
3. Agent Orchestrator: Manages the execution of complex, multi-step tasks.
4. Local Knowledge Layer: A hybrid data storage system that provides the AI's personal memory.

To visually represent how all client components interact with each other and the external network, the following conceptual architecture diagram is provided.

graph TD
    subgraph "Membria Client (User's Device)"
        A[User] --> B[UI/UX Interface]
        
        B --> C{Agent Orchestrator}
        
        C --> D[AI Core - Model Engine]
        C --> E[SkillForge - Skill Manager]
        C --> F[Local Knowledge Layer]
        
        D -.-> G[Local LLM]
        E -.-> G
        
        F --> H[SQLite - Chats, Logs, CAG]
        F --> I[DuckDB - RAG Index, Analytics]
    end

    subgraph "Decentralized Network"
        J[Gateways]
        K[Global Knowledge Graph - KCG]
        J <--> K
    end

    C -.->|"Knowledge Request"| J
    J -.->|"Response / Ranking"| C

This is the foundation upon which all other capabilities are built. The AI Core is designed for maximum flexibility and can operate in several modes to meet the needs of both beginners and experts.

1. Standard Mode (Built-in Engine) By default, the AI Core uses its own built-in engine to run models in GGUF format (e.g., Llama 3, Phi-3, Gemma, Mistral). It automatically starts a local OpenAI-compatible HTTP server, ensuring seamless operation of all Membria components. In this mode, the user is provided with a simple interface for managing basic resources (e.g., how many layers of the model to offload to the GPU).

2. Compatibility Mode (Integration with LM Studio, Ollama, etc.) Membria is not a closed system. If a user has already meticulously set up their models in popular tools like LM Studio or Ollama, they can switch the AI Core to compatibility mode. In this mode, Membria does not start its own engine but instead connects to the external local server run by these tools (e.g., http://localhost:1234/v1).

• Advantage: This allows the use of all of Membria's powerful features (Agents, SkillForge, Knowledge Layer) on top of the user's existing, pre-configured models, avoiding duplicate setups and resource consumption.

For power users and developers, an "Advanced Mode" is available that provides access to detailed settings for the core and the models, enabling maximum performance and generation quality:

• Fine-grained Generation Parameters: Direct control over parameters like temperature, top_p, top_k, and repetition_penalty for precise control over the creativity and determinism of responses.
• Sampler Control: The ability to change the order and methods of sampling (e.g., Mirostat) to influence the structure and quality of the model's output.
• System Prompt Editing: Customization and creation of unique system prompt templates that agents use to communicate with the model.
• Detailed Resource Management: More granular control over GPU layer distribution, number of CPU threads, context window size (n_ctx), batch size, and other GGUF-specific parameters.
• Verbose Logging: Enabling detailed logs for debugging the full text of prompts, model responses, and analyzing performance.

The Membria architecture embraces the principle that agentic systems are naturally heterogeneous. Instead of relying on a single, monolithic LLM, the AI Core is designed to be a flexible orchestrator.

An agent can use a powerful LLM for high-level planning or open-domain conversation, while calling upon various specialized and efficient SLMs for subordinate, well-defined tasks. This multi-model approach allows for an optimal balance of capability and cost-efficiency.

SkillForge is an innovative component that allows for the on-the-fly specialization of the base LLM.

• LoRA Patch Manager: The user can load LoRA adapters (.safetensors files) into the client, each representing a distinct "skill" (e.g., "Python programming," "legal text analysis").
• Dynamic Application: Before executing a request, the user or an agent can select which "skills" (LoRAs) to activate. The AI Core dynamically applies these LoRA patches to the base model, instantly adapting it to the specific task without needing a restart.

The SkillForge approach is built on the proven power and efficiency of specialized Small Language Models (SLMs).

• Proven Capability: Recent research demonstrates that well-designed SLMs can meet or exceed the performance of much larger models on specific agentic tasks. For example, the 8-billion parameter Salesforce xLAM-2-8B surpasses frontier models like GPT-4o and Claude 3.5 in tool-calling capabilities. Similarly, models in the Microsoft Phi series achieve reasoning and code generation scores on par with models 5-10 times their size.
• Economic Efficiency: A key advantage is cost. Serving a 7-billion parameter SLM is 10-30 times cheaper in terms of latency, energy, and FLOPs than a 70-175 billion parameter LLM. Furthermore, fine-tuning an SLM with techniques like LoRA requires only a few GPU-hours, as opposed to weeks for large models, enabling rapid iteration and adaptation.
• Behavioral Alignment for Reliability: For agentic workflows, reliability is paramount. An agent's interaction with tools requires strictly formatted outputs (e.g., JSON), and general-purpose LLMs may occasionally fail to adhere to these formats, causing errors. A specialized LoRA skill, however, can be cheaply and effectively fine-tuned to enforce a single formatting decision, ensuring near-perfect reliability for tool-use and system integration.

This component transforms the LLM from a simple chatbot into a proactive, thinking assistant capable of executing complex, multi-step tasks. Its basic features include access to tools (search, file system) and background task execution.

When a task requires dozens of steps, the standard approach of "fitting the entire history into the prompt" quickly leads to context window overflow. The Membria Agent Orchestrator solves this by implementing an advanced framework for reasoning and memory management. Instead of a static, growing prompt, it builds dynamic, evolving memory that functions like a human's mental scratchpad.

The Core Idea: Reasoning is a stateful process. Memory is not a history of dialogue in a prompt, but a compact latent state that the agent learns to update, compress, and utilize.

To achieve this, Membria's modular agents use an architecture with three key components ("heads"):

1. Reasoning Head: At each step, the agent first generates internal thoughts and reasoning.
2. Action Head: Based on this reasoning, the agent chooses a specific action—to call a tool or to respond to the user.
3. Memory Update Head: After executing an action, this head analyzes the result and compresses it, updating the latent memory state. It decides what to remember and what to forget.

To implement this complex memory mechanic, a hybrid, three-tiered approach based on the flexible capabilities of SQLite is used. Inspired by advanced enterprise systems, Membria also supports hierarchical memory structures. This means that for a complex task, a primary agent can spawn "child" agents, each with its own temporary memory context, which is "compressed" and returned to the parent agent upon completion. This ensures robust management of complex, multi-level projects.

1. Hot Memory (In-Memory): The agent's active state for maximum speed. This is implemented using SQLite's pure in-memory mode (sqlite3 :memory:) for active reasoning chains (reasoning_path) or through temporary tables (CREATE TEMP TABLE) for a session-level key-value cache (kv_cache). This ensures minimal latency by completely eliminating disk I/O.
2. Warm Memory (SQLite Persistence): A state journal for reliability and history. This is implemented using SQLite's hybrid mode, where the in-memory database is periodically backed up to a persistent file (BACKUP TO disk). This mechanism is used to maintain a persistent event log of the agent's actions (event_log), creating a reliable temporal graph of its reasoning.
3. Cold Memory (DuckDB): A vector archive for semantic search. Key conclusions from the SQLite state journal can be periodically vectorized and stored in DuckDB, enabling semantic search over the agent's own "memories."

• Optimization and Formats: To improve concurrent access performance, Write-Ahead Logging mode is used (PRAGMA journal_mode=WAL;). Complex data structures, such as reasoning steps, are stored as flexible JSON objects thanks to the built-in JSON1 extension support.
• Multi-Agent Collaboration: The architecture also allows for the use of SQLite's shared cache mode, enabling multiple agents or threads to work efficiently on a single task with a shared context.

To ensure reliability in enterprise tasks where errors are unacceptable, the Agent Orchestrator uses a mechanism based on the i-Check / Idem-Prompt concept. When an agent needs to call a tool that requires data in a strictly defined format (e.g., JSON), the orchestrator automatically wraps the LLM call in a constraining prompt. This prompt forces the model to output data in a stable, predictable, and always correct structure, which is critical for reliable automation.

Hallucinations in agents arise from context overload, context loss, or reasoning failures. The three-tiered memory system purposefully combats each of these issues:

1. Hot Memory Fights OVERLOAD: The agent works with a compact, "noise-free" state, not a giant prompt. This is like a clean desk versus one buried in paper, drastically reducing the risk of getting confused and hallucinating.
2. Warm Memory Fights AMNESIA: The SQLite state journal is a perfect, error-proof memory. To recall a past detail, the agent queries the database directly instead of trying to "guess." This eliminates hallucinations related to forgetfulness.
3. Cold Memory Fights REASONING FAILURES: Semantic search over past successful tasks acts like human experience. The agent uses proven reasoning patterns as templates, grounding its logic and preventing it from veering into illogical fabrications.

This is the "brain" and long-term memory of the personal AI, implemented on a dual-database system for maximum performance.

• SQLite (Transactional Core):
  • Purpose: Used as the primary operational database for frequent, small operations.
  • Stores: Full chat history, persistent agent event logs (event_log), user settings, model/skill metadata, and the Cache-Augmented Generation (CAG) cache of structured knowledge retrieved from the global network.
  • Advantage: Guarantees the reliability and integrity of operational data. Supports storing certain types of local indexes for search.
• DuckDB (Analytical Engine):
  • Purpose: Used as a specialized engine for resource-intensive searches over large volumes of unstructured data.
  • Stores: The Retrieval-Augmented Generation (RAG) index—vector embeddings generated from the user's local files (PDFs, DOCX, emails, etc.).
  • Advantage: Provides lightning-fast semantic search across millions of text fragments.

For maximum RAG accuracy, the Local Knowledge Layer employs an advanced Semantic Chunking method when indexing documents. Instead of splitting text into fixed-size fragments, this algorithm divides it along semantic and thematic boundaries. Each "chunk" represents a complete thought, which significantly improves the quality of vector representations, increases search relevance, and reduces hallucinations.

The analytical power of DuckDB isn't just for the AI's internal use; it's exposed to the user through an interactive dashboard. This transforms Membria from a simple tool into a true knowledge partner.

• Knowledge Graph Visualization: The dashboard can visually map how your documents, notes, and ideas are interconnected, revealing hidden relationships.
• Entity Analytics: The system automatically extracts and displays frequently mentioned entities (people, companies, technologies). Users can click on any entity to see all documents where it is mentioned.
• Interactive Agent Memory Map: The dashboard provides full transparency, allowing users to visually explore how an agent "thought" while solving a complex task.
• Discovering "Blind Spots": By analyzing your knowledge base, the system can suggest what information is missing and offer to find relevant data on the topic.

When local knowledge is insufficient, the client turns to the global network.

• Fast Response: A Gateway instantly searches the global Knowledge Graph (KCG) and returns the most reliable, previously verified information. The client does not need to wait for a new consensus.
• Two-Step Filtering and Ranking: To ensure quality, the client employs a powerful filtering system. It includes not only verification via "Teachers" (RLT) but also an advanced Ranking Layer. This layer evaluates and prioritizes all retrieved results (from both the network and local RAG search) based on their relevance, model confidence, and configurable corporate business rules (e.g., "documents from the 'Legal/Approved' folder always have the highest priority").

To ensure the complex verification system doesn't make the user wait, Membria's architecture is built on principles that minimize perceived latency.

• Optimistic Execution: The main principle is to provide an answer immediately while verification runs in the background. The client instantly shows the most likely answer with a "verifying..." status, which updates to "verified" upon completion.
• Aggressive Caching: The fastest response is one that doesn't require a network call. A multi-level caching system is used, first checking the client's ultra-fast local cache, then the gateway's cache.
• Adaptive Verification: The depth of verification can change. If an answer comes from a highly reputable source, the client may apply a "lightweight" check, saving time and resources.

Privacy and data security are not additional features; they are fundamental principles of the Membria architecture.

• Local by Default: All of your personal information—documents, chat histories, indexed files, and settings—is stored exclusively on your device. No data is uploaded to central servers without your explicit permission.
• Encryption at Rest: Local databases (SQLite, DuckDB) and configuration files can be encrypted using industry-standard practices (e.g., SQLCipher or OS-level file system encryption), protecting data even in the event of physical access to the device.

A modular system requires strict isolation to prevent abuse from third-party "skills" or agents.

• Permission Model: Similar to mobile apps, no skill or agent can access the file system, network, or other resources without explicit user permission. You always control what each component has access to.
• Sandboxing: The processes running agent logic can be executed in a sandboxed environment, which technically restricts their access to only the resources for which permission was granted.
• Reputation and Signatures: Skills distributed through the Membria ecosystem will have a digital signature from the author and a reputation system based on community feedback, helping to filter out questionable components.

• Fully Offline Mode: The client can operate in a 100% offline mode, completely disconnected from the internet. In this case, you achieve absolute "air-gapped" privacy.
• End-to-End Encryption: All communication between the client and Gateways is protected using modern encryption protocols (e.g., TLS 1.3), making data interception useless.
• Request Anonymization: When accessing the network, the client is designed to minimize the transmission of any personal information. Knowledge requests are generic and do not contain data that could identify the user.

The current local AI market is represented by excellent tools like Ollama, LM Studio, Jan, and others. Their primary function is to provide users with a simple and effective way to download and run open-source language models. They excel in this role as the "engine" or "driver" for LLMs. Membria does not so much compete with them as it extends their capabilities, offering to work in compatibility mode.

Membria takes the next step in the evolution of local AI. If competitors focus on HOW TO RUN a model, Membria focuses on WHAT THE MODEL CAN DO after it's running. We are building not just an engine, but a complete operating system for personal AI, where the model is merely the kernel that receives memory, skills, and the capacity for autonomous action.

[cite_start]The SLM-first philosophy of Membria is not just a design choice; it is supported by extensive academic research into the efficiency and capability of modern language models[cite: 2]. This research also provides strong counter-arguments to common objections.

• Objection 1: "LLMs' general understanding will always give them an edge." This view posits that even on narrow tasks, the superior general reasoning of an LLM will trump a specialized SLM. However, this argument is flawed because:

  • Popular scaling law studies assume a fixed model architecture, whereas recent work shows that different architectures are optimal for different model sizes.
  • This view ignores the power and flexibility of fine-tuning. An SLM can be easily and cheaply specialized for the task at hand to perform at the desired level of reliability.
  • Reasoning techniques (like Chain-of-Thought) are significantly more affordable to run on an SLM at inference time to boost performance.

• Objection 2: "Centralized LLM inference will always be cheaper due to economy of scale." This argument claims that the cost benefits of SLMs are outweighed by the operational efficiencies of massive, centralized data centers. While this is a valid business consideration, recent trends indicate a shift:

  • Advanced inference scheduling systems (like NVIDIA Dynamo) offer unprecedented flexibility, countering the traditional load-balancing challenges of specialized models.
  • The costs associated with setting up private inference infrastructure are on a consistent downward trend due to technological improvements.

Membria is the "application layer" that installs on top of the "drivers" (like Ollama) and transforms a static LLM into a proactive, learning, and truly useful personal assistant. We give local AI a brain, memory, and hands.

This section connects the local client's technology with the global mission of Membria described in the summary. It explains how a self-sustaining, decentralized economy is created to reward participants for their contributions. To achieve this, SkillForge evolves from a simple local manager of LoRA files into a full-fledged gateway to a decentralized marketplace.

1. For Creators (Experts):
   • Any expert in their field (law, medicine, a rare programming language, financial analysis) can create their own LoRA skill. For example, a cybersecurity expert can fine-tune a model on all vulnerability reports from the last 5 years, creating a "Cyber Threat Analyst" skill.
   • They publish this skill on the Membria Marketplace, setting a price in the project's native tokens. They also provide a detailed description, usage examples, and undergo a verification process to confirm the quality and safety of their product.
2. For Users (Consumers):
   • A typical Membria user, facing a task that requires highly specialized knowledge, browses the marketplace built into the client.
   • They find the skill they need, read its description, and check its rating and reviews from other users.
   • With a single click, they purchase the skill using tokens. The skill is automatically downloaded into their SkillForge, and they can begin using it immediately, dramatically increasing their local AI's competence in that specific domain.

• Economic Incentives for Knowledge Creation: A direct and clear motivation emerges for experts worldwide to share their knowledge. Creating a high-quality LoRA skill becomes a digital asset that generates income.
• Exponential Growth of Ecosystem Capabilities: The platform becomes populated with thousands of niche skills that would be impossible to create centrally. Do you want an AI sommelier? Or an AI expert in repairing antique clocks? They can emerge on the marketplace thanks to enthusiasts.
• Real Utility for the Token: The project's token ceases to be a speculative asset and acquires fundamental utility. It becomes the internal currency for exchanging knowledge—the most valuable resource in this ecosystem.
• Competition and Quality: Skill creators will compete with one another, which will continually drive up quality and drive down the price of expertise, making it accessible to all.

Thus, the marketplace closes the economic loop, gives the token real utility, and transforms Membria from just a powerful tool into a living, self-improving, and economically incentivized knowledge ecosystem.

To ensure a high level of trust and reliability for skills on the marketplace, Membria will implement an evaluation mechanism inspired by research into "Evaluating LLM Self-Knowledge". Before publication, each model or LoRA skill can be automatically benchmarked to determine its ability to recognize the limits of its own knowledge. The result, displayed as a "Reliability Score" or "Self-Awareness Index," will help corporate and individual users choose the most dependable tools for critical tasks.

The marketplace is not just a place to sell skills; it is part of a continuous improvement loop fueled by real-world usage data. The process for creating new, high-quality skills for the marketplace is directly inspired by the "LLM-to-SLM Conversion Algorithm".

1. Step 1: Secure Data Collection: With user consent, the Agent Orchestrator can be configured with a Logger component. This component logs all non-HCI (Human-Computer Interaction) agent calls—capturing anonymized input prompts, output responses, and tool call data.
2. Step 2: Curation and Clustering: Once a sufficient dataset is collected, it is curated to remove any sensitive information. Then, unsupervised clustering techniques are employed to identify recurring patterns and common tasks that are ideal candidates for specialization.
3. Step 3: SLM Selection and Fine-tuning: For each identified task cluster, an appropriate base SLM is selected. A new, specialized LoRA skill is then created by fine-tuning the SLM on the task-specific dataset, leveraging PEFT techniques like LoRA. This process can also use knowledge distillation to transfer capabilities from a more powerful mode.
4. Step 4: Publishing and Refinement: The new skill is published to the marketplace. This entire process forms a continuous loop, where new data from agent interactions is used to refine existing skills and create new ones, ensuring the ecosystem constantly adapts and improves.

This section demonstrates how Membria's architecture solves concrete, real-world problems. A key element of the user experience, especially in a corporate environment, is the Visual Workflow Orchestrator. Inspired by the "intuitive canvas" concept, this provides a graphical interface where even non-technical experts can construct complex agent task chains by dragging and dropping pre-defined action blocks.

• Persona: Anna, a Senior Python Developer.
• Task: To fix a critical bug in a large, confusing project she has never seen before.

Workflow with Membria:

1. Project Indexing: Anna points the Membria client to the project's source code folder. The Local Knowledge Layer indexes all files in the background (RAG).
2. Skill Acquisition and Activation: Anna browses the marketplace and purchases the top-rated "Python Legacy Code Expert" skill. She activates it in SkillForge.
3. Dialogue with the Agent: Anna writes a request: "Trace the data path from the API endpoint /api/v1/user/profile to the database response and find where the administrator rights check is missing."
4. Result: The Agent Orchestrator, using RAG on the code and the knowledge from the purchased LoRA skill, builds a call graph and, within a minute, provides a precise answer identifying the problematic function and recommending a fix.

Even a future version of Cursor powered by GPT-5 would be a brilliant generalist. Membria's approach provides surgical precision where general knowledge is not enough. The key advantage is the ability to fine-tune a LoRA skill specifically on Anna's company codebase. Such a skill would know every internal API and unwritten convention of that project. A GPT-5-powered Cursor would give excellent general Python advice, but Membria's LoRA skill will give advice that is perfectly relevant for that specific system.

• Persona: Victor, a Market Analyst.
• Task: To prepare a summary report on global investments in green energy over the last three years, based on 75 PDF reports.

Workflow with Membria:

1. Data Ingestion: Victor drags the folder of PDFs into Membria. The Local Knowledge Layer indexes all documents.
2. Complex Task Delegation: He gives the agent a multi-step task to analyze, synthesize, and structure data from all documents.
3. Autonomous Work: The Agent Orchestrator works in the background for several hours. Its dynamic working memory allows it to maintain context, compare data from different reports, and build a coherent picture.
4. Result: Victor receives a complete, structured report with tables and conclusions, saving weeks of manual labor.

Membria's advantage lies in the autonomy of the agent and its stateful memory. It doesn't just answer questions about documents; it executes a long-term research project. It "remembers" its intermediate findings, can compare data from document #5 with conclusions from document #42, identify contradictions, and synthesize entirely new information.

• Persona: Elena, a lawyer at a tech company.
• Task: To review a software development agreement that includes elements of AI model licensing.

Workflow with Membria:

1. Context Creation: All of the company's standard agreements and technical documentation are already indexed in the Local Knowledge Layer.
2. Multi-Skill Activation: Elena browses the marketplace and purchases two skills: "IT Contract Analysis" and "Software Licensing." She activates both of them simultaneously in SkillForge.
3. Complex Task Delegation: She asks the agent: "Compare this contract to our standard template. Highlight all legal risks that arise from the technical obligations."
4. Result: The agent, possessing expertise in both domains, identifies a clause where a technical requirement to use a library under a GPL license creates a legal risk for the entire product.

Membria's strength is synthesis. A standalone "Legal AI" won't understand the technical risks, and a standalone "Code AI" won't understand the legal consequences. Membria's ability to dynamically combine multiple skills creates a temporary "super-expert" (in this case, an "IT Law expert") who sees the full picture and finds risks at the intersection of two domains.

One of the most requested features for a personal AI is the ability not just to search the web, but to conduct deep, multi-stage research on a given topic. The Membria client handles this as an autonomous project managed by the Agent Orchestrator.

To perform this function, the Agent Orchestrator utilizes the existing modules:

1. The "Brain" (Agent Orchestrator): Acts as the "project lead," decomposing the topic into sub-tasks and forming a research plan.
2. The "Senses" (Tools): The agent is provided with a web_search tool to get a list of URLs and a web_browser tool to "visit" those links.
3. The "Memory" (Hybrid Memory): Uses all three memory tiers (hot, warm, cold) to manage context, log steps, and recall successful strategies.

To ensure maximum privacy and control, web access is implemented via a hybrid model:

• Step 1: Retrieving Links (API-dependent). To search and retrieve a list of URLs (web_search), the agent accesses an external API. The recommended solution is the Brave Search API, as it is privacy-focused and offers a generous free tier.
  • Cost: For the vast majority of users, this is free, as the free tier (up to 2,000 queries per month) covers standard needs. For power users who exceed this limit, an option is provided in the settings to add their own API key for a "Pay-as-you-go" model.
• Step 2: Browse Pages (Fully Local). After receiving a list of links, the agent uses the web_browser tool, which runs entirely locally on the user's device.
  • Solution: The Membria client integrates a headless browser based on Playwright. The agent programmatically "opens" a page in this invisible browser, waits for it to fully load (including JavaScript), and extracts its content.
  • Cleaning: The content is then processed by a local scraper (based on a library like trafilatura) to remove ads, menus, and other boilerplate.
  • Advantage: This approach guarantees that the content of the pages you browse never leaves your device, ensuring maximum privacy and reliability.

The agent decomposes the user's topic into a multi-step plan. It then iteratively uses the web_search tool to get links and the local web_browser tool to scrape and analyze content from those links. It uses its dynamic memory to synthesize findings from dozens of sources, notes contradictions, and builds a coherent picture. The entire process is logged for auditability. Once complete, the agent generates a structured report and indexes the findings and key sources into the user's permanent Local Knowledge Layer.

Beyond research, the Membria agent architecture is perfectly suited for performing complex web automation tasks, creating a powerful, local, and private alternative to services like Autotab. This is achieved by extending the agent's toolset for web interaction.

While the Research Agent primarily "reads" the web, the Automation Agent can "act" upon it. This is managed by the same core components but with an expanded set of tools.

1. The "Brain" (Agent Orchestrator): The Orchestrator receives a high-level goal, such as "Find the top three electric scooters on Amazon with a rating above 4.5 stars under $500, and save their names, prices, and links into a CSV file on my desktop." The Reasoning Head decomposes this goal into a concrete, step-by-step plan.
2. The "Eyes and Hands" (Local Browser and New Tools): The agent uses the same local Playwright-based browser but is equipped with a new suite of interactive tools:
   • read_visible_elements(): "Reads" the page to understand what buttons, forms, and links are available.
   • type_in_element(selector, text): Enters text into a form field.
   • click_element(selector_or_description): Clicks a button or link.
   • write_to_csv(file_path, data): A tool to interact with the local file system.
3. The "Memory" (Hybrid Memory System): The agent's memory is crucial for reliability. Every action (clicked button X, filled form Y) is logged in the "Warm Memory" (SQLite). If a step fails (e.g., a page doesn't load correctly), the agent can consult its memory, understand what went wrong, and retry the step or adjust its plan, rather than starting from scratch.

1. See: The agent navigates to a webpage and uses read_visible_elements(). The LLM receives a description like: "Found an input element with id='twotabsearchtextbox'."
2. Think: The Reasoning Head decides: "My goal is to search. This element is the search bar. I need to type 'electric scooter' into it."
3. Act: The Action Head calls the type_in_element("input#twotabsearchtextbox", "electric scooter") tool.
4. Update Memory: The agent logs the successful action in its SQLite journal and proceeds to the next step in its plan.

• Integration: The agent is not just a "browser bot." It can seamlessly combine web automation with other skills. For example, after scraping scooter data, it could use a "Hardware Analyst" LoRA skill to evaluate the specifications.
• Reliability: The stateful memory system makes the agent far more robust and resilient to errors than simple automation scripts.
• Privacy: The entire Browse and interaction process runs locally on the user's machine, ensuring credentials and activity remain private.

For enterprise clients where privacy, security, and data control are absolute priorities, the Membria architecture adapts. The public, decentralized network is replaced by a private, fully controlled corporate ecosystem.

In this model, the "Gateway" ceases to be an access point to an external network. It becomes an internal, secure "Corporate Gateway" or "AI Service Bus", operating exclusively within the company's network perimeter. Users' local clients interact only with this gateway.

Behind the Corporate Gateway lies not a "zoo" of disparate models, but a single, powerful core: a large language model built on the MoEX (Mixture-of-Experts) architecture.

The key innovation of this approach is that the "experts" within this MoEX model are fine-tuned and specialized on the knowledge bases and competencies of specific company departments:

• Expert #1: Fine-tuned on all documents from the Legal department.
• Expert #2: Fine-tuned on the entire technical documentation and codebase of the Engineering department.
• Expert #3: Fine-tuned on the databases and regulations of the HR department.
• Expert #4: Fine-tuned on data from the Finance department, and so on.

The MoEX model's internal router automatically determines which expert (or combination of experts) to activate for each specific query.

1. Seamless Cross-Domain Synthesis: This is the primary advantage. When an agent needs to analyze a task at the intersection of domains (e.g., legal risks in a technical contract), the MoEX router activates multiple experts ("Legal" and "Engineering") simultaneously. They work together to generate a single, holistic answer.
2. Efficiency and Speed: Despite a massive total parameter count, MoEX models use only a fraction of them for any given query. This provides the knowledge of a huge model with the inference speed and cost closer to that of a much smaller model.
3. Scalability and Manageability: It is far easier for an IT department to manage, update, and secure one central MoEX model than dozens of separate systems. Adding a new department's knowledge equates to training and "plugging in" a new expert.
4. Unified Knowledge Base: The model itself becomes the single, dynamic "source of truth" for the entire company's knowledge.

In the Membria corporate architecture, agents operate on a sophisticated hybrid model that creates a dynamic division of labor between the local client and the central corporate MoEX LLM. This approach is designed to optimize for speed, privacy, and power, ensuring that tasks are executed at the most appropriate and efficient level.

The user's local Membria client acts as the "tactical brain" and "hands" of the operation. It manages the immediate workflow and handles all tasks that do not require deep, cross-domain corporate knowledge. Its responsibilities are:

• Task Decomposition and Planning: When a user provides a high-level goal, the Agent Orchestrator running locally takes charge. Its Reasoning Head breaks the goal down into a logical sequence of steps. This entire planning process happens on the user's machine, ensuring it is fast and private.
• Local Context and Tool Use: The agent first attempts to resolve each step using local resources. This includes performing RAG searches on the user's private files via the Local Knowledge Layer and utilizing local tools like the file system I/O or the Playwright-based browser for web automation. This keeps sensitive data secure.
• State Management and Error Recovery: The client locally manages the agent's "hot" (in-memory) and "warm" (SQLite log) memory. This allows it to meticulously track its progress, prevent redundant actions, and gracefully recover from errors (e.g., a failed web page load) without needing to re-consult the powerful central model.
• Simple Inference: For minor, self-contained tasks like reformatting text, classifying an email's intent, or extracting data based on a simple pattern, the agent can use a small, efficient SLM running locally via the AI Core.

The local orchestrator makes a deliberate and intelligent decision to "escalate" a task to the central model only when necessary. The central Corporate MoEX LLM is not involved in every step; it is queried like a highly specialized, internal consultant.

• Deep Analysis and Synthesis: When a step requires deep, cross-domain knowledge that resides outside the user's local context (e.g., "analyze this new draft agreement against our company's global risk framework"), the local agent sends a well-formed query to the Corporate Gateway.
• Access to a Unified Corporate Knowledge Base: The MoEX model's experts (e.g., Legal, Finance, HR, Engineering) are trained on the entire company's unified knowledge base. They can answer questions that no single user's local data could address, breaking down information silos across the organization.
• Complex Generation Tasks: For tasks that require sophisticated generation based on company-wide standards, such as drafting a full legal document from a corporate template or writing a formal report, the superior generative power of the large central model is utilized.

User Goal: "Analyze the risks in this new software license agreement I just received."

1. [LOCAL] - Task Planning: The user provides the goal and the new license document. The Membria client's Agent Orchestrator creates a plan:
   • Step A: Read and parse the new license document.
   • Step B: Retrieve our company's standard software agreement templates for comparison.
   • Step C: Identify all clauses in the new license related to technical obligations and data privacy.
   • Step D: Assess the legal and compliance risks of these clauses based on our corporate standards.
   • Step E: Generate a summary report of the findings.
2. [LOCAL] - Local Data Retrieval: The agent executes Step B by performing a RAG search on the Local Knowledge Layer to find the company's standard legal templates, which were previously indexed.
3. [CENTRAL] - Expert Analysis Query: For Step D, the local agent realizes it needs deep legal and technical expertise. It sends a request to the Corporate Gateway containing the text of the new license and the relevant clauses from the internal templates. The prompt is: "Activate 'Legal' and 'Engineering' experts. Analyze the provided license text against our standard clauses and identify all risks where technical commitments (e.g., use of specific open-source libraries) create a conflict with our standard legal terms."
4. [CENTRAL] - MoEX Processing: The Corporate MoEX LLM receives the query. Its router activates the "Legal Expert" and the "Engineering Expert". They work in concert to analyze the request and generate a detailed analysis of the cross-domain risks.
5. [LOCAL] - Report Generation: The local agent receives the expert analysis from the central model. It now has all the components it needs. It executes the final step (Step E) by using its local LLM to format the findings into a clean, concise summary report for the user.

This synergistic model provides the best of both worlds: the privacy, speed, and autonomy of a local client, combined with secure, on-demand access to the immense power and comprehensive knowledge of a centralized corporate AI.

Of course. I will add this detailed diagram and its description as a new, separate subsection within the "Architecture for Corporate Clients" section of the final English document.

Here is the updated section.

The following diagram illustrates the complete hybrid workflow model, showing how a user on a local client can leverage both centrally-managed Corporate Agent Templates and a Visual Workflow Orchestrator to execute tasks that are dynamically split between local resources and the central Corporate MoEX LLM.

flowchart TD
 subgraph subGraph0["Corporate MoEX LLM (Strategic Brain)"]
        Router{"Router / Gating Network"}
        Expert_Legal["Legal Expert"]
        Expert_Eng["Engineering Expert"]
        Expert_Finance["Finance Expert"]
        Expert_Etc["..."]
  end
 subgraph subGraph1["Corporate Network (Private Cloud / On-Premise)"]
    direction LR
        Templates[("Corporate Agent Templates")]
        Gateway["Private Corporate Gateway"]
        subGraph0
        CKG[("Unified Corporate Knowledge Graph")]
  end
 subgraph subGraph2["Interface (UI/UX Layer)"]
        VWO["Visual Workflow Orchestrator"]
        Chat["Standard Chat/Prompt UI"]
  end
 subgraph subGraph3["Local Resources"]
        LocalTools["Local Tools - Browser, Files"]
        LocalRAG@{ label: "Local Knowledge Base - RAG on user's files" }
        LocalSLM["Local SLM - for simple tasks"]
  end
 subgraph subGraph4["User's Device (Local Client)"]
        User["User"]
        subGraph2
        Orchestrator["Agent Orchestrator"]
        subGraph3
  end
    Router -- activates --> Expert_Legal & Expert_Eng
    Gateway --> Router
    Expert_Legal --> CKG
    Expert_Eng --> CKG
    Expert_Finance --> CKG
    User -- Builds Workflow --> VWO
    User -- Gives Prompt --> Chat
    VWO -- Constructed Plan --> Orchestrator
    Chat -- "High-Level Goal" --> Orchestrator
    Orchestrator -- Local Actions --> LocalTools
    Orchestrator -- Search Local Files --> LocalRAG
    Orchestrator -- Simple Formatting --> LocalSLM
    Templates -- Download Agent Template --> Orchestrator
    Orchestrator -- Escalate Complex Query --> Gateway
    Gateway -- Expert Answer --> Orchestrator
    Orchestrator -- Final Report --> VWO & Chat
    LocalRAG@{ shape: rect}
    style Templates fill:#e6e6fa,stroke:#333,stroke-width:2px
    style VWO fill:#e6e6fa,stroke:#333,stroke-width:2px
    style User fill:#c9f,stroke:#333,stroke-width:2px
    style Orchestrator fill:#f9f,stroke:#333,stroke-width:4px

This diagram illustrates the most advanced operational mode for the Membria corporate client, combining central governance with local flexibility.

1. Corporate Agent Templates:

   • A new entity, Corporate Agent Templates, exists within the secure corporate network. This repository holds pre-configured, IT-approved agent templates for common business tasks (e.g., data extraction, report generation).
   • Step 0: Before initiating a task, the user's Agent Orchestrator can download a relevant template. This provides the agent with a standard, reliable baseline logic and toolset for its mission.

2. Visual Workflow Orchestrator:

   • The UI/UX Layer on the client is shown with two methods for task initiation: the standard chat interface and the more advanced Visual Workflow Orchestrator.
   • Step 1: Instead of just writing a text prompt, a user can visually construct a complex, multi-step workflow using a drag-and-drop canvas. This constructed plan is then passed to the Agent Orchestrator for execution, making powerful automation accessible to non-technical users.

The rest of the flow proceeds as previously described: the local "Tactical Brain" executes what it can using local resources (Step 2a, 2b, 2c), escalates complex queries requiring deep corporate knowledge to the central "Strategic Brain" (Step 3), receives the synthesized expert answer (Step 4), and generates the final report for the user (Step 5).

This section describes the most advanced level of the Membria client's operation in a corporate environment. The architecture doesn't just provide access to knowledge; it creates a self-improving, adaptive task execution system that combines centralized governance with personalized local efficiency.

The company's IT department can create and maintain an internal library of agent templates. These are not just prompts, but pre-configured agent "skeletons" for solving common business tasks, inspired by the KnowledgeVerse approach.

• Data Entry Agent: A template for automatically filling forms, such as expense reports or applications.
• Data Extraction Agent: A template for extracting structured data from documents like invoices, resumes, or legal acts.
• Data Comparison Agent: A template for comparing different document versions and identifying semantic or stylistic differences.
• Report Generation Agent: A template for automatically updating weekly or monthly reports based on new data.

A user downloads the required template from the corporate library directly into their local Membria client to perform a specific task.

The downloaded agent template is not a static program. A key innovation is its ability for on-the-fly dynamic self-modification to execute the user's task with maximum precision, using the client's local resources. This is a business-oriented alternative to visual analysis systems like PyVision, where the agent adapts not to a visual interface, but to the context of the business task.

How it works in practice:

1. Task: A user asks the Data Extraction Agent to extract data from 50 invoices from a new supplier, which have a non-standard format.
2. Context Analysis: The agent, using its base logic from the template, processes the first document. It "understands" that its standard instructions are not a perfect fit for this unique structure.
3. Local Self-Modification: Instead of sending 50 complex requests to the central MoEX LLM, the agent uses local inference (on a small SLM built into the client). It generates a temporary, single-use "micro-skill"—this could be a set of hyper-specific instructions or even a "micro-LoRA"—perfectly "tuned" to extract data from these specific invoices. To ensure the reliability of these instructions, it uses principles similar to Idem-Prompt to make the output stable and predictable.
4. Efficient Execution: By applying this temporary "micro-skill," the agent quickly and accurately processes the entire batch of 50 documents, operating far more efficiently and cheaply than if it had constantly queried the central model.

• Precision and Personalization: Agents adapt to the unique nuances of a specific user's tasks and data, ensuring the highest accuracy where standard templates fall short.
• Reduced Load on the Central LLM: 95% of routine, repetitive work is performed locally. Requests to the expensive central MoEX LLM are sent only to solve truly complex, non-trivial parts of a task.
• Maximum Security: The confidential data from the user's documents is used for local adaptation and never leaves their computer.
• Flexibility and Control: The user gets the power and standards of corporate templates but retains the ability to fine-tune them on the fly for their specific needs, achieving a perfect balance between centralized governance and personal efficiency.

Membria is born from a simple yet profound observation: the current revolution in local AI is incomplete. While powerful language models can now run on personal devices, they exist as static, amnesiac tools—brilliant but fundamentally limited, like a genius with no memory or connection to the outside world. This document has detailed the architecture of the Membria Client, which is designed to solve this problem comprehensively.

Membria is not just another application; it is an AI Operating System built on three core pillars:

1. Agency and Memory: Beyond mere inference, Membria introduces true agency. Its advanced Agent Orchestrator, equipped with a dynamic, stateful memory system, allows AI to execute complex, long-horizon tasks without suffering from context explosion or hallucinations. By managing memory across hot (in-memory), warm (transactional log), and cold (semantic search) tiers, it transforms a stateless model into a reflective, thinking partner.
2. Specialization and Skill: Recognizing that a single model cannot be an expert in everything, Membria's SkillForge architecture provides a mechanism for deep, modular specialization. Through dynamically loaded LoRA skills—created by experts and shared on a decentralized Marketplace—a generalist model can instantly become a surgical expert in niche domains, from analyzing proprietary codebases to understanding complex legal contracts.
3. Knowledge and Growth: Membria shatters the "static brain" problem by creating a hybrid knowledge system. The Local Knowledge Layer gives the AI a perfect, searchable memory of the user's personal world (RAG). Crucially, this is connected to the global, ever-growing Membria network, allowing the agent to pull fresh, validated information from the outside world (CAG). This ensures the AI is not only personalized but also perpetually learning and up-to-date.

The result is a paradigm shift in what a personal AI can be. It moves from a passive "co-pilot" that responds to commands to a proactive, autonomous partner that can manage projects, conduct research, and synthesize knowledge across multiple domains. All of this is accomplished within a "privacy-by-design" framework that keeps the user's data on their device by default, giving them ultimate control.

Membria is the missing piece that completes the puzzle of personal artificial intelligence. It is the foundation for a future where every user is equipped with an AI that is truly their own—private, adaptable, and perpetually growing smarter with them.