Real Memory AI Agent

Private AI agent execution for real developer work.

Real Memory AI Agent is a multi-surface AI agent for VS Code, Chrome, Edge, terminal, web companion workflows, and MCP tools. It gives tenants one controlled place to ask for work, choose model flows, connect providers, inspect projects, edit files, validate changes, capture proof, review outcomes, and keep activity recoverable.

Product: Real Memory AI | Publisher: Reallexi LLC

Store-facing visuals are loaded from the public GitHub media repository, not local media/ paths, so marketplace pages, private repo previews, tenant decks, and investor links render without requiring source repository access.

Support

• GitHub Sponsors: https://github.com/sponsors/ddkits
• Buy Me a Coffee: https://buymeacoffee.com/ddkits

Help Test Real Memory AI Agent

We are looking for developers, agencies, AI builders, browser power users, and teams with real projects to test Real Memory AI Agent and tell us what works, what breaks, and what would make it more useful.

Testers can try the agent in the surfaces they already use:

• VS Code: install the VSIX, open the RM AI Agent chat, connect a provider, and ask it to inspect, edit, validate, document, or explain a real workspace.
• Chrome: load or install the Chrome package, open the side panel, connect a provider, inspect a tab, capture proof, and try browser-safe actions.
• Edge: install the Edge package or load the unpacked build, then test the same side-panel workflow in Microsoft Edge.
• CLI: run chat, ask, and run commands from the terminal for fast local project workflows and automation checks.
• MCP: start the local MCP runtime and verify that compatible clients can reach workspace, terminal, memory, and doctor tools.

What we need feedback on:

• First install experience: what was confusing, slow, missing, or blocked?
• Provider setup: which provider worked, which failed, and what error message helped or did not help?
• Real work results: did it make the correct edits, inspect the right context, validate properly, and summarize honestly?
• Browser behavior: did tab selection, sessions, screenshots, artifacts, and page actions feel clear?
• Workflow visibility: did the TODO/current-step accordion make the order of work, completed steps, and blockers clear?
• Accessibility and UI: can you navigate by keyboard, understand states, read the layout, and recover from errors?
• Trust: did approvals, review records, activity logs, and artifact proof make the run easier to trust?

Best tester report format:

Surface: VS Code / Chrome / Edge / CLI / MCP
OS:
Provider and model:
Task tried:
What worked:
What failed or confused me:
Screenshot/log/artifact if available:
What would make me use this again:

If you share this project with another tester, send them this README plus the VSIX and browser zip packages from the Packaging And Distribution section.

Product Promise

Real Memory AI Agent turns AI from a chat window into a private execution layer.

It can help a tenant team:

• Build, repair, refactor, document, test, and validate code projects.
• Ask direct model questions with the selected provider and model.
• Inspect real workspace files and active editor context.
• Generate and update Markdown, reports, project docs, code, configuration, and scripts.
• Run approved workspace commands and validation checks.
• Capture UI screenshots and browser evidence.
• Open browser tabs, inspect pages, click visible controls, submit simple page messages, download generated files, and save artifacts.
• Track sessions, activity, provider status, model responses, reviews, screenshots, and files changed.
• Show a compact workflow TODO accordion with the ordered plan, current next step, completed steps, and blockers in VS Code, Chrome, and Edge.
• Approve, reject, or revert file changes through a review-first workflow.
• Keep local-first, tenant-controlled model workflows without forcing a single cloud provider.

The product is designed to handle any approved task that fits inside its connected workspace, browser, terminal, provider, and tenant permission boundaries.

Screenshots

Chat Workspace

The chat view presents tenant work as a clean conversation with model, planner, backend, and OS context visible at the top. Internal logs stay out of the main chat until the Activity Log is opened.

Browser Side Panel

The browser side panel gives Chrome and Edge testers tab-aware chat, screenshots, artifacts, activity, and provider settings without leaving the current page.

CLI And MCP

The terminal and MCP surfaces make the same agent mission testable from scripts, setup doctors, local runtime checks, and compatible tool clients.

Sessions And Menu

The session menu exposes configuration, website access, activity log, session creation, rename, deletion, and clear-chat actions without overwhelming the chat surface.

The Four Flows

Real Memory AI Agent supports four model flows so tenants can choose speed, simplicity, specialization, or automatic routing.

These flows are available across the VS Code extension and provider-backed runtime. The browser extension also exposes Direct Model and provider settings in a side panel.

Provider Network

Real Memory AI Agent is provider-flexible by design. Tenants can bring local models, cloud APIs, enterprise endpoints, or custom OpenAI-compatible services.

Supported provider families include:

• Ollama
• llama.cpp
• Docker-hosted local endpoints
• NVIDIA NIM
• OpenAI
• Azure OpenAI
• OpenRouter
• xAI
• Anthropic
• Gemini
• RealMemory services
• Custom OpenAI-compatible endpoints
• Custom exact endpoint URLs

Provider abilities:

• Model selection by provider.
• Provider-aware endpoint and API key settings.
• Streaming responses where supported.
• Model refresh and provider connection testing where available.
• Local loopback browser support for localhost and 127.0.0.1 provider URLs.
• Provider-neutral Direct Model tool use.
• Clean error/status reporting in the chat, settings, activity, and browser side panel.

Tenant Value

Real Memory AI Agent is built for tenants who need AI work done in private projects, not generic demos.

For Developers

• Ask for features, bug fixes, UI updates, docs, refactors, tests, and debugging.
• Keep project context inside the workspace.
• Use the same agent from VS Code, CLI, browser, web UI, and MCP.
• Review changes before accepting them.
• See validation results, proof screenshots, and artifact outputs.
• Switch model flow and provider without changing the work surface.

For Agencies

• Move from client request to implementation, validation, review, and delivery summary.
• Keep each client workspace separate.
• Produce Markdown reports, proof artifacts, and reviewable changes.
• Use local or client-approved providers.
• Export and inspect activity when delivery proof matters.

For Enterprise Tenants

• Bring your own model provider and endpoint policy.
• Use local-first or private-cloud provider strategies.
• Keep approval gates around file writes and command execution.
• Preserve activity logs, artifacts, screenshots, and review records.
• Support developer teams without forcing one model vendor.

For AI Platform Tenants

• Expose private model value inside real developer workflows.
• Connect hosted models, custom endpoints, or account-backed services.
• Offer a practical agent surface that can produce visible work, not only answers.
• Expand from VS Code to browser, CLI, web, and MCP without changing the user promise.

Investor View

Real Memory AI Agent is positioned as a private AI operating layer for software work.

The strategic opportunity:

• Multi-surface wedge: VS Code, browser side panel, CLI, web companion, and MCP runtime.
• Provider independence: local models, major cloud APIs, custom endpoints, and tenant-owned infrastructure.
• Tenant retention: persistent sessions, review flows, artifacts, validation proof, and workspace memory make repeated work valuable.
• Enterprise fit: approval controls, private provider keys, local-first paths, and evidence-backed completion.
• Distribution-ready packaging: VSIX package, Chrome package, Edge package, CLI, and MCP runtime.
• Expansion path: hosted RealMemory services, private model routing, validation intelligence, browser automation, tenant dashboards, and managed agent workflows.

The product direction is simple: give every tenant a private agent that can understand the request, use the right model flow, act in the right surface, show proof, and leave a clean record.

What The Extension Provides

VS Code Agent

• Chat-first workspace assistant.
• Model, planner, backend, mode, and thinking controls.
• Sessions and conversation history.
• Workspace file reading, searching, writing, and replacement.
• Active editor context.
• Diagnostics and project inspection.
• Command execution with approval controls.
• Validation, retry, and repair workflows.
• Review banner with changed file count.
• Diff review, approve, reject, and revert actions.
• Activity Log for detailed runtime status.
• Debug backflow levels: None, Simple, or Detail for provider/runtime diagnostics.
• Screenshot validation for UI work.
• RealMemory login and model selection commands.
• Local setup, setup doctor, MCP start/stop, and provider readiness commands.

Chrome And Edge Browser Agent

• Manifest V3 side panel.
• Direct provider calls from the browser extension.
• Provider selection and model selection.
• Refresh models and test connection actions.
• Direct Model flow.
• Persistent extension-owned IndexedDB state.
• Clean chat, activity, artifacts, and settings tabs.
• Active tab metadata.
• Visible tab screenshots.
• Browser-safe page actions.
• Downloads for generated/exported content.
• Model-response artifacts.
• Review state display.
• Local loopback provider support through browser extension rules.
• Clean failure messages with visible diagnostics and recovery actions.

Terminal CLI

• Chat from the terminal.
• Provider and model selection.
• File context commands.
• Workspace search and read commands.
• Approved writes and shell commands.
• Diff, undo, export, and status commands.
• Session-oriented workflow for power users and automation.

Web Companion

• Browser-accessible companion UI.
• Shared agent experience for chat, model flow, and project workflows.
• Private deployment path for tenant environments.

MCP Runtime

• Workspace tools.
• Terminal tools.
• Setup and doctor tools.
• Memory tools.
• Optional web research routing.
• Reusable tool network for agent-compatible clients.

Smart Capabilities

Real Memory AI Agent is built around abilities tenants can feel in daily work:

• Ask naturally: request work the way a project owner would describe it.
• Choose the right flow: Auto, Direct Model, Single Model, or Planner + Coder.
• Bring any provider: local, cloud, enterprise, or custom endpoint.
• Stay private: use tenant-owned files, endpoints, keys, and local models.
• Act on real projects: read, edit, validate, document, and review actual workspace files.
• Use browser context: inspect active pages, capture screenshots, download artifacts, and handle simple page actions.
• Keep proof: screenshots, artifacts, activity, validation output, and final summaries.
• Review safely: approve, reject, or revert changed files.
• Recover work: sessions, queue state, artifacts, and logs survive reloads.
• Scale surfaces: the same agent promise works in editor, browser, terminal, web, and MCP.

Use Cases

Product And Engineering

• Fix build failures.
• Repair broken React, Node, TypeScript, Python, or web projects.
• Update UI design and responsive layouts.
• Add features and forms.
• Convert rough requests into project-ready changes.
• Write tests and validation scripts.
• Generate project documentation and release notes.
• Explain code and architecture to new team members.

Browser And Web Work

• Ask questions against the selected model from Chrome or Edge.
• Inspect the active tab.
• Capture screenshot proof.
• Open pages and perform visible simple actions.
• Generate downloadable browser artifacts.
• Keep activity and model output visible in the side panel.

Tenant Operations

• Prepare client deliverables.
• Create internal technical reports.
• Validate UI work before reporting done.
• Maintain private workspace memory.
• Switch between local and external providers by policy.
• Keep sensitive provider keys outside public chat prompts.

Controls Tenants Expect

• Provider selection.
• Model selection.
• Four model flows.
• Auto-approve controls.
• Tool and shell permission settings.
• Direct Model tool controls.
• Validation and repair limits.
• Screenshot settings.
• Provider request mode.
• Context and output size settings.
• Activity detail level.
• Browser extension settings.
• Review and revert controls.

Packaging And Distribution

The private repo can produce all tester-facing and tenant-facing packages locally.

npm install
npm run compile
npm run package

Outputs include:

• VS Code VSIX package.
• Browser extension unpacked build in chrome-extension/dist/.
• Chrome package in chrome-extension/packs/real-memory-browser-agent-chrome.zip.
• Edge package in chrome-extension/packs/real-memory-browser-agent-edge.zip.
• CLI entry points through npm run cli-ui -- ... and npm run cli -- ....
• Setup, doctor, validation, MCP, and packaging scripts through root npm run commands.

Every root npm run package first runs the shared version bump script. The same new version is written to the VS Code package, MCP runtime package, root lockfile, browser package, browser lockfile, and Chrome/Edge manifest so the VSIX, Chrome zip, Edge zip, and installed About screens all identify the same build. Testers can confirm the exact build in the VS Code Settings About panel, the RM AI Agent: About command, or the browser side-panel Settings About card.

Browser-only package commands:

npm --prefix chrome-extension run build
npm --prefix chrome-extension run pack:all

Root shortcuts:

npm run extension:browser:build
npm run extension:browser:pack
npm run extension:browser:pack:nobump
npm run extension:chrome:pack
npm run extension:edge:pack

Recommended tester bundle:

• *.vsix from the VS Code package step.
• chrome-extension/packs/real-memory-browser-agent-chrome.zip.
• chrome-extension/packs/real-memory-browser-agent-edge.zip.
• This README.md.
• chrome-extension/README.md for browser-specific installation and feedback notes.
• GitHub script guide: https://github.com/ddkits/Ollama-VScode-Free-Agent/blob/main/scripts/README.md

Installation Surfaces

Use this as the quick tester map:

VS Code

Install the VSIX package, then open:

RM AI Agent: Open Chat

Useful commands:

RM AI Agent: Open Configuration
RM AI Agent: Open Activity Log
RM AI Agent: Local Setup
RM AI Agent: Setup Doctor
RM AI Agent: Start MCP Server
RM AI Agent: Stop MCP Server

Chrome Or Edge

Build the browser extension, then load chrome-extension/dist/ as an unpacked extension or install the packaged zip.

After manifest or permission changes, reload the unpacked extension or reinstall the latest package so browser permissions and local provider rules are active.

CLI

npm run cli-ui -- info
npm run cli-ui -- config --show
npm run cli-ui -- chat
npm run cli-ui -- ask "Why is my build failing?"
npm run cli-ui -- run "Fix the project and validate it" --dry-run
npm run cli-ui -- explain README.md "What should a new tester try first?"
npm run cli -- export-tracker

CLI scripts are useful for testers who prefer terminal workflows, want to reproduce an issue quickly, or want to validate setup without opening the VS Code or browser UI.

Common CLI actions:

/help
/status
/tools
/settings
/model <name>
/agent <name>
/ls
/read <path>
/search <text>
/write <path>
/diff
/undo
/export md

See the GitHub script guide for the full tester-oriented CLI, setup, doctor, package, and validation script guide: https://github.com/ddkits/Ollama-VScode-Free-Agent/blob/main/scripts/README.md

Validation And Proof

Real Memory AI Agent is designed to finish work with proof when the workspace supports it.

Useful validation commands:

npm run compile
npm test
npm run mcp:doctor
npm run browser:install
npm run browser:test
npm --prefix chrome-extension run build
npm --prefix chrome-extension run pack:all
node .\node_modules\mocha\bin\mocha test\chrome-extension-browser-pack.spec.js

Proof outputs can include:

• Test results.
• Build output.
• Activity logs.
• Model response artifacts.
• Browser screenshots.
• UI validation screenshots.
• Review records.
• Changed file summaries.
• Markdown delivery summaries.

Privacy And Control

• Tenants choose providers, models, endpoints, and keys.
• Local provider workflows can stay on the tenant machine.
• Browser-agent memory is stored in extension-owned storage.
• Workspace changes are reviewable before approval.
• Shell commands and writes are controlled by settings and permissions.
• Browser extension actions stay within browser extension capabilities.
• Custom endpoints support tenant-specific AI infrastructure.

Private Repository Note

This repository is private. Store-facing README screenshots and public listing visuals must use the public media repository:

• https://github.com/ddkits/Reallexi-Public-media-and-files/tree/main/realmemory/store
• Raw image base: https://raw.githubusercontent.com/ddkits/Reallexi-Public-media-and-files/main/realmemory/store/
• Product website: https://realmemoryai.com
• Publisher website: https://reallexi.io

For tenant or investor sharing, package the VSIX and browser zips, then share the artifacts and this README as the product overview.

License

MIT