Knowledge & Memory

Where to find knowledge and memory settings

From your main dashboard, open the agent you want to train and go to the full editor. In the editor, the teaching surfaces are spread across a few related areas:

• The Knowledge section inside the agent editor is where you upload files, add URLs, and monitor what has been ingested.
• The Memory section is where you control how much the agent remembers, how long it keeps things, and whether it should learn automatically.
• The Agent Configuration Files area is where you edit the markdown files named SOUL.md, MEMORY.md, KNOWLEDGE.md, HEARTBEAT.md, and USER.md.
• The Instructions and Soul & Personality sections help your agent interpret what it knows and how it should behave with that information.

If you are in a hurry, start with the Knowledge section first. If you want deeper control, add the markdown files and adjust the memory rules afterward.

What belongs in knowledge

Knowledge is best for information that should stay stable across many conversations. If you would normally hand a new employee a folder, binder, playbook, training packet, or FAQ, that content probably belongs in knowledge.

Good examples include:

• Product catalogs and service descriptions
• Pricing sheets and policy documents
• Frequently asked questions
• Internal SOPs and step-by-step processes
• Sales scripts and objection-handling notes
• Intake forms and onboarding packets
• School materials, study guides, and class notes
• Family schedules, house rules, and recurring routines
• Travel plans, event itineraries, and reservation details
• Brand voice guides and messaging standards

The goal is not to upload everything you have. The goal is to upload the information your agent should confidently rely on again and again.

What belongs in memory

Memory is different. Memory is for things the agent learns or should retain over time about a person, a conversation, or an ongoing relationship. In the runtime, NetShow can keep track of recent session context, extract useful facts and preferences, and summarize longer conversations into reusable memory. That means the system can do more than just read a document. It can remember that a client prefers texts over calls, that a customer always books on Thursdays, or that you like short answers instead of long explanations.

Good uses for memory include:

• Personal preferences
• Recurring client details
• Long-term context from repeated conversations
• Facts that make future answers more useful
• Summaries of multi-step discussions
• Relationship context between people, projects, and topics

In plain language, knowledge is what you teach deliberately. Memory is what the agent can retain so you do not have to repeat yourself.

Uploading files to the Knowledge section

Inside the Knowledge section, you will see a large upload area designed for drag-and-drop on desktop and tap-to-upload on mobile. This is where you add documents directly to the agent. The interface is built for practical business and personal use, not just experiments, so treat it like a working library for your agent.

Start with your clearest materials first. Upload the documents that answer the questions your agent is most likely to get in the real world. If you run a business, that may be your service guide, policy page, and FAQ. If you are building a personal assistant, that may be your calendar notes, recurring routines, and a household guide.

As a rule of thumb:

• Upload clean, final documents instead of messy drafts
• Use files with clear headings and structure when possible
• Break giant mixed-purpose documents into smaller focused ones if you can
• Remove outdated information before uploading
• Avoid duplicating the same content across many files

After upload, NetShow queues the document for processing. Your agent does not merely “store” the file. The platform prepares it so the agent can search and pull the right parts when needed. If you uploaded a file and the agent still seems vague, the first thing to check is whether the content was too broad, too outdated, or too inconsistent.

Adding URLs and web pages

The Knowledge section also gives you a URL input so you can teach the agent from live web content. This is useful when your best information already exists on a public or internal web page and you do not want to copy and paste it into a separate file.

URLs are especially helpful for:

• Company websites
• Help center pages
• Pricing and policy pages
• Public menus, service pages, and listings
• Event pages or schedules
• Internal documentation pages

Use URLs when the source is maintained somewhere else and you want the agent to learn from that source. Use uploaded files when you want tighter control over exactly what the agent knows.

If a page changes often, review it regularly. Your agent can only be as current as the source material you feed it.

What the processing queue means

After you upload a file or submit a URL, NetShow places that item into a queue. This is normal. The platform needs time to read the content, structure it, and make it usable inside retrieval. In the editor, you may see progress or status indicators while this is happening.

While an item is processing:

• It may not be fully available to the agent yet
• Test answers may still rely on older knowledge
• Large documents may take longer than small ones

Once processing finishes, the content becomes part of the agent's working knowledge. If you are testing right after upload, give the system a moment and then ask a very direct question that clearly depends on the new material. That is the fastest way to confirm the upload worked.

How to write better source material

Your agent does better when your source material is written for humans first. Dense jargon, duplicate paragraphs, and contradictory instructions all make it harder for the agent to respond confidently.

Better source material usually has:

• Clear headings
• Short paragraphs
• Plain-language answers
• Defined rules and exceptions
• Specific examples
• Consistent terminology

If you are creating a new file just for your agent, imagine you are writing a handbook page for a new teammate on their first day.

Understanding the Memory section

The Memory section gives you control over what the agent should retain after conversations. In the current runtime, NetShow can inject recent session context, recall stored facts and preferences, and save summaries of longer interactions when memory features are enabled. That means the settings here affect not only what the agent remembers later, but also what context it can bring into the next conversation.

Common settings in this area include:

• Auto-learn: lets the system save useful facts and preferences without you manually adding every single one
• Auto-archive: helps move older information out of the active layer when it is no longer hot
• Privacy mode: gives you tighter control when you want less automatic retention
• Retention controls: decide how long memory should stick around
• Maximum memory size: prevents memory from growing without limits
• Manual memory entries: lets you add important facts on purpose

If you are not sure where to start, keep memory conservative. Let the agent remember stable preferences and important facts, but avoid turning every conversation into permanent history unless that truly serves your use case.

Session memory versus long-term memory

One of the most useful distinctions in NetShow is the difference between session memory and long-term memory.

Session memory is the immediate context from the current conversation. It helps your agent stay coherent from one message to the next so it does not forget what you just asked three turns ago. This is what makes a back-and-forth conversation feel smooth.

Long-term memory is what survives beyond the current session. That is where saved facts, preferences, and conversation summaries matter. If someone says, “I prefer morning appointments,” and the memory rules allow it, the system can bring that preference back later instead of making the person repeat it.

Not every fact deserves long-term storage. A good memory system remembers what is useful and lets go of what is not.

Manual memory entries

If there is something your agent absolutely must remember, add it manually. This is one of the safest ways to create reliable behavior because you are telling the system exactly what to keep.

Useful manual memory examples:

• “Michael prefers concise answers with action steps.”
• “The Smith family uses text messages for scheduling, not phone calls.”
• “This clinic does not schedule new-patient visits after 4:00 PM.”
• “The client’s favorite package is the premium monthly plan.”

Manual memory is especially helpful when you already know a preference or rule that should shape future conversations right away.

The markdown consciousness files

NetShow gives you five markdown files that act like a control layer around the agent. These files are powerful because they let you shape the agent with readable plain text instead of hiding everything behind form fields.

`SOUL.md`

This file is where you define who the agent is at its core. Use it for personality, values, tone, non-negotiables, and the kind of presence you want the agent to have. If the agent should feel calm, reassuring, precise, upbeat, or deeply professional, this is where you spell that out.

Think of SOUL.md as the inner character sheet. It answers questions like:

• How should this agent treat people?
• What tone should it default to?
• What values should it protect?
• What should it refuse to do?

`MEMORY.md`

This file describes how memory should be interpreted and prioritized. It is a good place to explain what kinds of facts deserve retention, what should be treated as temporary, and what privacy boundaries matter.

Use MEMORY.md when you want the agent to handle memory deliberately instead of casually. For example, you can clarify that client preferences should be remembered, but sensitive personal details should only be retained with care.

`KNOWLEDGE.md`

This file gives high-level guidance about the knowledge base itself. Use it to tell the agent how to use uploaded material, what sources to trust first, and how to behave when the knowledge base is incomplete.

This is useful when you want the agent to say, “I do not have enough information yet” instead of guessing. It is also helpful when you have multiple sources and want the agent to favor one type over another.

`HEARTBEAT.md`

This file supports proactive behavior. If your agent sends reminders, check-ins, or scheduled nudges, HEARTBEAT.md is where you describe the spirit of those interactions. It can define when the agent should reach out, what kind of tone those messages should have, and what counts as helpful versus intrusive.

`USER.md`

This file is for the human on the other side. Use it to capture context about the owner, primary user, or target audience the agent serves. This helps the agent adapt its language and priorities to the person it is helping.

If SOUL.md explains who the agent is, USER.md explains who the agent is here for.

A simple way to use the files together

You do not need to overcomplicate the markdown system. A strong setup often looks like this:

• SOUL.md: who the agent is
• MEMORY.md: what the agent should remember
• KNOWLEDGE.md: what sources the agent should rely on
• HEARTBEAT.md: how the agent should proactively follow up
• USER.md: who the agent is serving

If you keep those roles clear, your agent becomes easier to manage and much more predictable.

How memory and knowledge work together in conversations

When someone talks to your agent, NetShow can pull from more than one layer at once. The runtime may use current conversation context, remembered facts and preferences, and relevant knowledge sources to build a better answer. That is why a well-trained agent feels more grounded. It is not just “making something up.” It is pulling from the information structure you built.

For example, imagine a real estate agent using NetShow. The uploaded knowledge might include office policies, listing FAQs, and neighborhood descriptions. The memory layer might remember that one lead prefers evening showings and is most interested in two-bedroom properties near a specific school district. Together, those two layers create a much better follow-up experience.

Best practices for safer, clearer memory

Before you turn memory all the way up, decide what your agent should and should not keep. This matters for quality and trust.

Good practice looks like:

• Remembering useful preferences
• Storing facts that improve service
• Reviewing sensitive content carefully
• Avoiding unnecessary personal detail
• Keeping source material current
• Testing after every major upload

If you are working in a sensitive field, pair your memory setup with the Security section so the agent’s behavior matches your standards.

How to test whether teaching worked

After you upload documents or adjust memory settings, move to Test Drive and ask the kind of question a real user would ask. Do not ask vague questions like “Do you know my files?” Ask practical questions instead.

Good test prompts include:

• “What is our return policy for annual plans?”
• “What tone should you use when answering new prospects?”
• “What do you remember about my preferred appointment times?”
• “Use the uploaded training guide to explain our onboarding steps.”

If the answer feels weak, do not assume the whole system failed. Usually the fix is simpler:

• improve the source material
• make the instruction more explicit
• add a missing manual memory fact
• remove conflicting content
• give the file more time to process

A practical first setup

If you want a reliable starting point, do this:

1. Upload your top three documents.
2. Add one important URL.
3. Turn on sensible memory retention.
4. Add two or three manual memory facts.
5. Write a short SOUL.md and USER.md.
6. Test with five real-world questions.

That setup is enough to move an agent from generic to genuinely useful.

What happens next

Once your knowledge and memory are in place, the next best step is usually one of two things: test the agent in a real conversation, or move into deployment. Testing helps you see whether the agent sounds informed. Deployment is what turns that informed agent into something people can actually use on the web, over text, or on the phone.

You do not need perfect memory architecture on day one. Start with the information your agent needs most, teach it clearly, and improve it as you see real conversations. NetShow is built so your agent can grow from a simple helper into something that feels genuinely aware of your world.