Demo agents
Standalone reference agents built on Jennah without internal dependencies. The Python and TypeScript demos use the Python SDK and the TypeScript SDK over gRPC, and authenticate via API keys or jnh login sessions. The Go agents use the HTTP/JSON API authenticated with a jennah_sk_ API key.
Overview of available demo agents:
| Agent | Shape | Leans on |
|---|---|---|
| memchat (Python) | interactive chatbot | semantic recall + automated formation (synchronous client) |
| LangChain adapter | retriever + async chat agent | semantic recall + background formation (asynchronous client) |
| memchat (TypeScript) | interactive chatbot | semantic recall + automated formation |
| memchat | interactive chatbot | semantic recall + automated formation + the fact graph |
| memscout | autonomous researcher | execution log (resume) + deep multi-hop graph |
| memwatch | headless watcher on a cron | semantic dedup + run-by-run timeline |
| memsteward | codebase mapper | log as per-file state + structural graph |
Both memchat ports and the Go agents persist only the agent_instance_id locally in
an <agent>-state.json file. Agent state resides in Jennah, allowing restarted
processes to resume execution. Delete the state file to reset local state.
Each agent creates a workspace under the shared demo. namespace (for example,
demo.memchat_<random> or demo.memscout_<random>). Because . is the
agent-selector delimiter and matching is segment-anchored, a role with selector
demo.* matches all demo workspaces without granting access to production agents.
Common setup
Applies to all demo agents.
Prerequisites
- A Jennah API key from an enterprise whose trial is still active (or that
has been upgraded). If you haven't minted one yet, follow
Getting started (Onboard → mint an API key) - signing in is
all it takes, there's no approval step. The
jennah_sk_secret is shown once. - A chat/reasoning model - Anthropic, Claude on Amazon Bedrock (an AWS
profile allowed to call
bedrock:InvokeModelon theglobal.anthropic.claude-sonnet-5-5inference profile), or Gemini (via Vertex AI with a GCP project + ADC, or via Google AI Studio with an API key). The LangChain example supports Anthropic and Gemini only. - Python 3.10+ for the Python demos, Node.js 22.12+ for the TypeScript demo, or Go 1.26.5+ for the Go agents.
Point the agents at your key and a model
The Jennah key is the same everywhere; the model brain is pluggable. Export your key, then pick one provider:
# Nothing to export: choose Bedrock explicitly
# and name an AWS profile. Go agents shown; the
# memchat Python and TypeScript ports take
# --provider and --aws-profile.
go run . -provider bedrock -aws-profile my-profile
-aws-region defaults to ap-northeast-1. Pass the profile with
-aws-profile rather than AWS_PROFILE: when AWS_ACCESS_KEY_ID is also
exported, it silently takes precedence over AWS_PROFILE, and the calls run
in that key's account instead.
-provider auto (the default) picks Anthropic when an Anthropic key is
present, otherwise Gemini; it never picks Bedrock. Force a provider with
-provider anthropic|bedrock|gemini (the LangChain example takes
--provider auto|anthropic|gemini and has no Bedrock option). Every agent prints the brain it chose on
start, e.g. anthropic/claude-sonnet-5-5 or
bedrock/global.anthropic.claude-sonnet-5-5.
Common flags
The Go agents share common command-line options: -verbose (display memory
queries, deduplication decisions, and commit receipts), -endpoint http://127.0.0.1:8090
(target a local proxy), and -region us-central1 / $JENNAH_REGION (set
the agent home region on first launch; list options with jnh agents regions).
With -provider bedrock, -aws-region and -aws-profile choose the AWS
region and the named profile that signs requests. Credentials can also be
passed via flags (-jennah-api-key, -anthropic-api-key) instead of
environment variables. memscout, memwatch, and memsteward also take -show
(print stored memory and exit without invoking the model).
Python
The Python demos authenticate using $JENNAH_API_KEY or stored credentials from jnh login. Model provider configuration matches the setup described above.
memchat (Python)
An interactive chatbot using the synchronous SDK Client to maintain conversation history across sessions. By default, memory is formed automatically on the server (memory:form), with formation receipts and retired assertions displayed after each turn. --authored enables client-side extraction using a remember_fact tool and memory:commit against the same workspace.
Try it: Provide a fact, submit a correction in a later turn, and restart the process. The agent recalls the updated fact and marks the superseded assertion as retired ((+1 retired, not shown)).
LangChain adapter
langchain-jennah integrates Jennah with LangChain, providing a BaseRetriever for semantic recall and a JennahMemory class whose form_memory / aform_memory methods form memory from LangChain message lists. The target workspace is bound during adapter initialization, exposing a tool schema that requires only a query argument. The repository includes an asynchronous chat agent demonstrating background memory formation during conversation.
git clone https://github.com/nightblue-io/langchain-jennah/
cd langchain-jennah/
pip install ".[examples]"
python examples/chat.py
Try it: Send two messages in rapid succession. The second response generates while the first formation runs asynchronously in the background. If terminated while background tasks are active, the agent completes pending formations before exiting.
TypeScript
The TypeScript demo authenticates using $JENNAH_API_KEY or stored credentials from jnh login. Model provider configuration matches the setup described above.
memchat (TypeScript)
An interactive chatbot using the SDK Client to maintain conversation history across sessions. By default, memory is formed automatically on the server (memory:form), with formation receipts and retired assertions displayed after each turn. --authored enables client-side extraction using a remember_fact tool and memory:commit against the same workspace.
For a lasting memchat-ts command, install it from a clone:
git clone https://github.com/nightblue-io/jennah-memchat-ts/
cd jennah-memchat-ts/
npm install
npm install -g .
memchat-ts --verbose
Try it: Provide a fact, submit a correction in a later turn, and restart the process. The agent recalls the updated fact and marks the superseded assertion as retired ((+1 retired, not shown)).
memchat (TypeScript) on GitHub
Go
Four agents written in Go, each communicating over HTTP/JSON using a jennah_sk_ API key.
The common flags described above apply to all Go agents.
memchat
An interactive chatbot that maintains conversation history across sessions. By default, each turn is formed into memory on the server (memory:form), and recall combines semantic search with the knowledge graph read back through memory:inspect. -authored uses client-side extraction with a remember_fact tool and memory:commit against the same workspace.
git clone https://github.com/nightblue-io/jennah-memchat/
cd jennah-memchat/
go build -o memchat .
./memchat -verbose
Try it - tell it something about yourself, quit (/exit or Ctrl+D), then
run it again and ask what it remembers:
you> Hi, I'm Alice, I'm a backend engineer in Berlin and I'm learning to sail.
...quit, relaunch...
you> what do you remember about me?
memscout
An autonomous research agent that executes multi-step investigations, persisting execution logs for process resumption and building knowledge graphs.
git clone https://github.com/nightblue-io/jennah-memscout/
cd jennah-memscout/
go build -o memscout .
./memscout -verbose -goal "what is the origin of music?"
Try it - let it research a handful of subquestions and stop on its own (or at
-max-steps, default 12), then read back or query what it built - no new research,
and -show needs no LLM:
Run it again with the same goal to resume: the planner sees what the log already covers and pushes into new ground.
memwatch
A headless monitoring agent designed for cron execution that diffs observed data against stored semantic memory to detect and report new items.
git clone https://github.com/nightblue-io/jennah-memwatch/
cd jennah-memwatch/
go build -o memwatch .
# First run: name the subject (remembered thereafter)
./memwatch -verbose -subject "the AI agent memory / context platform market"
# Subsequent runs: the subject is remembered, just run it again
./memwatch -verbose
# Print the entity graph + run timeline, then exit
./memwatch -show
Try it - run it twice a few minutes apart; the second run reports only the new
items and skips the ones it already knows (N new, M already known). Then wire it
to a scheduler (cron, a systemd timer, a CI cron) and let it run unattended - it
never re-reports what it has already seen.
Where the news comes from
For a self-contained demo the developments come from the chat model itself.
A real deployment swaps a web-search / RSS / news API in at the
brain.observe seam - every Jennah memory call stays exactly the same.
memsteward
A codebase mapping agent that tracks repository file hashes in its execution log to detect changes and structural dependencies.
git clone https://github.com/nightblue-io/jennah-memsteward/
cd jennah-memsteward/
go build -o memsteward .
./memsteward -verbose -repo /path/to/repo # first run analyzes everything
./memsteward -verbose -ext .go,.py,.ts -repo . # analyze more than Go
Try it - point it at a small repo and let it finish, then edit one file and
run it again: it reports 1 modified, N unchanged (skipped) because it remembered
every file's last hash. Delete a file and re-run to see the drift. Then -show
to read back the graph it built.
Next steps
- Review the agent source code linked above for
memory:queryandmemory:commitusage. The memory API is identical across all agents; only the model provider integration and control loop differ. - Explore the full API Reference.