SDK Knowledge Prompts

The Pod-OS Go SDK (pod-os-go-client) ships a set of knowledge prompts: authoritative, embedded reference documents that describe how the platform actually works—communication, message handling, and Evolutionary Neural Memory. Feeding these to a coding agent (such as Cursor) grounds its design and implementation in the real protocol instead of guesswork, which dramatically reduces incorrect message formats and Intent usage.

Use them together with live verification: prompts for design and shape, podos for confirmation. See Testing Code Paths with podos for the verification half of the loop.

What the knowledge prompts cover

Document	What it teaches your agent
Communication	The Actor/Gateway model, `<actor>@<gateway>` addressing, connection and ID sequence, and STREAM ON vs. STREAM OFF modes.
Message Handling	Message structure (addresses, header, numeric type, payload), the connection event sequence, and how requests map to responses.
Neural Memory (Events)	The three primitives—Event Objects, Tags, and Links—plus efficiency guidance (e.g. prefer `StoreBatchEvents`, batch sizing) and ownership/reference rules.
Neural Memory (Retrieval)	Pattern search, programmable/compound searches, buffered results, and how to query data effectively.

These are the "why and how" behind the platform. Pair them with the SDK's Intent field validation reference, which is the authoritative spec for per-Intent required fields and wire format—the single most common thing to get wrong when constructing messages by hand.

Accessing the prompts from the SDK

The knowledge documents are embedded in the knowledge package of pod-os-go-client, so they are available at build time with no external files:

import "github.com/PointOfData/pod-os-go-client/knowledge"

// List the available documents
names := knowledge.ListDocuments()

// Fetch one by name (e.g. "communication", "message-handling",
// "neural-memory", "neural-memory-retrieval")
doc, err := knowledge.GetDocument("neural-memory")
if err != nil {
    // handle unknown document name
}
// `doc` is the full markdown reference, ready to hand to a coding agent.

Because the documents are plain markdown strings, you can print them, write them to a file, or pipe them straight into a coding-agent prompt.

Using knowledge prompts with a coding agent

A reliable design-and-implementation loop:

Prime the agent. Before asking the agent to design a feature, give it the relevant knowledge document(s). For a data-modeling task, provide Neural Memory (Events) and (Retrieval); for wiring up a Socket Actor's messaging, provide Communication and Message Handling.
Design against the model. Ask the agent to propose the Actors, Intents, tags, and links using the vocabulary and rules from the prompts—not generic assumptions.
Implement with the validation spec. When the agent writes message-construction code, have it follow the Intent field validation reference for required fields and wire format.
Verify live. Use podos to run the proposed Intents against a running Actor Network and feed the JSON (including any validation errors) back to the agent to correct the code.

Prompts describe the contract; podos proves it. Knowledge prompts get the agent's first draft close; live validation closes the gap. Do not rely on recalled field names—verify mechanically.

Which document for which task

You are building…	Start with
A Socket Actor that connects and answers messages	Communication, Message Handling
Code that stores or links events	Neural Memory (Events) + Intent field validation
Search and retrieval logic	Neural Memory (Retrieval)
Anything constructing raw messages by hand	Intent field validation (required fields + wire format)

Next: revisit Working with Socket Actors to apply this guidance, or return to the Welcome overview.