Demo agents
Four standalone reference agents built on Jennah. Each agent communicates over HTTP/JSON authenticated with a jennah_sk_ API key without importing internal dependencies.
Overview of available demo agents:
| Agent | Shape | Leans on |
|---|---|---|
| memchat | interactive chatbot | semantic recall + a one-hop 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 |
They all persist just one thing locally: the agent_instance_id, in a
<agent>-state.json file. Everything an agent knows lives in Jennah, so killing
and relaunching any of them resumes where it left off. Delete the state file
to start fresh.
Each one creates its workspace under the shared demo. namespace -
demo.memchat_<random>, demo.memscout_<random>, and so on. Since . is the
agent-selector separator and matching is segment-anchored, a role carrying the
single selector demo.* reaches every workspace all four demos mint - and no
other agent - so you can try them with a throwaway API key that has no reach into
your real agents.
Common setup
Do this once; it applies to all four 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 - either Anthropic or Gemini (via Google AI Studio with an API key, or via Vertex AI with a GCP project + ADC).
- Go 1.21+.
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:
-provider auto (the default) picks Anthropic when an Anthropic key is
present, otherwise Gemini; force it with -provider anthropic|gemini. Every
agent prints the brain it chose on start, e.g. anthropic/claude-sonnet-5.
Common flags
All four agents share a few knobs: -verbose (show memory queries, dedup
decisions, and commit receipts), -show (print what's in memory and exit -
no LLM call), -endpoint http://127.0.0.1:8090 (target a local proxy), and
-region us-central1 / $JENNAH_REGION (pin the agent's home region on
first launch; list options with jnh agents regions). Keys can also be
passed as flags (-jennah-api-key, -anthropic-api-key) instead of env
vars.
memchat
An interactive chatbot that maintains conversation history across sessions using semantic recall and a knowledge graph.
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
- Read any agent's source (linked above) to see each
memory:queryandmemory:commitcall an agent makes - the memory API is identical across all four; only the LLM brain and the loop around it differ. - Explore the full API Reference.