Pull that up, Jamie!
Jamie is not a Nostr client and not a wallet. It belongs in AI because the core product is semantic podcast research and agent orchestration. Its Nostr and NWC relevance comes from paid agent access, Alby/NWC payment flows, Nostr sharing and backend Nostr automation code.
What Jamie really is
Pull that up, Jamie! is best understood as podcast intelligence infrastructure. The public site describes an AI-powered way to search podcasts by meaning, explore ideas in 3D and turn long conversations into findable moments. That is the right starting point. Jamie is not primarily a social client, a wallet, a relay or a Lightning node. It is a hosted search and research system built around podcast transcripts, semantic retrieval, agent orchestration and clipable source material.
The product has two faces. For humans, it is a web app where you can search a corpus, inspect feeds and episodes, save moments into research sessions, analyze a session and create clips. For agents and developers, it exposes a public API, an OpenAPI file, an llms.txt file and a higher-level `/api/pull` endpoint that can plan and run podcast research tasks. That machine door is why Jamie belongs in this Nostr apps collection even though it is not a normal Nostr timeline app.
The important correction is scope. Jamie's Nostr and NWC story is real, but it is not the center of the product in the same way semantic podcast search is. NWC appears as a payment rail for agents and L402 credentials. Nostr appears in web sharing, creator/social account flows and backend automation code. If you open Jamie expecting a Nostr client, you will misunderstand it. If you open it as an AI research engine with Lightning-paid machine access, the design makes sense.
Why it belongs in AI
Jamie belongs in the AI category because the primary promise is semantic understanding of spoken material. You ask for ideas, quotes, themes, people or source moments, and the system searches transcript meaning instead of only matching titles or exact words. The root site says it can search more than 100,000 podcast clips by meaning, and the live corpus stats endpoint shows a much larger backend footprint than the older public copy implies.
The API confirms that shape. The OpenAPI file describes semantic quote search using embeddings and Pinecone, chapter search, podcast discovery, corpus navigation, on-demand transcription, research sessions, AI analysis, clip creation and the `/api/pull` agent. The Jamie Pull agent guide goes further: the endpoint can call tools, stream status events, return markdown answers, include clip tokens and suggest follow-up actions. That is an AI research workflow, not a simple media directory.
For a reader, this distinction matters because AI systems can sound confident while hiding weak retrieval, stale corpus data or ambiguous attribution. Jamie gives you source-linked podcast moments, which is better than a generic chatbot answer, but you still need to open the clips, read transcripts in context and check whether the answer truly supports the claim.
The live corpus is large and moving
The corpus numbers are worth treating carefully. Jamie's llms.txt and ClawHub skill copy still mention an older scale of roughly 109 feeds, 7,000 episodes and 1.9 million paragraphs. The live `/api/corpus/stats` endpoint returned a much bigger current snapshot on June 13, 2026: 355 feeds, 130,918 episodes, 834,627 chapters, 25,336,581 paragraphs, 166,782 people and 445,801 topics. The endpoint was slow from this environment, but it did return a generated timestamp for that day.
That mismatch is not automatically a problem. It is common for fast-moving products to update APIs faster than marketing copy, package descriptions or skill directories. But it means a serious user should prefer live endpoints and official machine-readable docs over old summaries. If you are building an agent workflow, call the stats endpoint, read the corpus spec and test search behavior against feeds you actually care about.
The live corpus also changes the practical value of Jamie. A few thousand episodes make a useful demo. More than one hundred thousand episodes and tens of millions of paragraphs make it closer to a research substrate. The bigger the corpus, the more important ranking, filters, source review and result deduplication become.
Semantic search is the core primitive
The lowest-level Jamie feature to understand is search. The OpenAPI spec exposes `/api/search-quotes` for semantic search across transcripts. It accepts a query and can filter by feed IDs, episode GUIDs, dates and episode names. The backend README describes the broader stack as a mix of vector search, MongoDB Atlas Search, reranking and model-assisted intent handling. In plain language, Jamie tries to find the passage that means what you asked, even when the speaker did not use your exact words.
This is why Jamie can be useful for podcast research. Podcasts are long, conversational and hard to skim. A phrase might be discussed over several minutes without landing in the episode title. A guest might explain an idea in an aside. A creator might return to a theme across many feeds. Search by meaning lets you ask for the concept instead of guessing the phrase.
The risk is that semantic search is not truth. It is retrieval. A result can be adjacent to the idea, quoted out of context or less relevant than the model ranking suggests. The right workflow is to use Jamie to find candidate moments quickly, then open the underlying transcript, inspect neighboring paragraphs and listen to the clip before citing it.
Corpus navigation keeps the work grounded
Jamie does not only expose search. The corpus API has read-only endpoints for stats, feeds, feed details, episodes, episode chapters, topics, people and people appearances. The corpus spec says these endpoints are meant for navigation and discovery, with pagination and common limits. That structure is important because good research needs more than one search box.
Feed and episode endpoints let you narrow the domain before asking a model to reason. People endpoints help you find guest appearances, but the docs are careful that this is about appearances rather than every mention of a person. Topic and chapter endpoints give another way into the corpus when a query is too broad. The Jamie Pull guide also describes adjacent paragraph retrieval, which is exactly the feature you want when a clip token looks promising but needs context.
For a user, this means you should not treat the first generated answer as the whole result. Use the API shape as a checklist: which feed did this come from, which episode, which chapter, which paragraph, what was said before and after, and whether the person field means guest appearance or textual mention.
The Jamie Pull agent
The most important agent-facing endpoint is `POST /api/pull`. The official client guide describes it as a multi-tool agent that can call semantic search, chapter search, podcast discovery, on-demand transcription, research sessions, clip creation, people lookups, feed lookups, episode lookups and adjacent paragraph retrieval. Instead of forcing an agent to choose every low-level endpoint manually, `/api/pull` can plan the task and stream the work.
The endpoint can return JSON or server-sent events. The SSE mode includes status updates, tool call events, tool results, text deltas, suggested actions, session-created events, done events and errors. That matters for real agent clients because a long podcast research task should not feel like a black box. The UI can show what the agent is searching, which tools it called and when it created a session.
The agent response can also include clip tokens such as `{{clip:pineconeId}}`, which clients can hydrate into richer result cards through hierarchy endpoints. That design keeps the generated answer connected to source moments. It is still AI output, but it is AI output with handles back into the corpus.
L402 is the machine-payment layer
Jamie is especially relevant to NWC because of its L402 payment model. The docs describe paid endpoints returning a 402 response with a Lightning invoice and a macaroon-style credential challenge. A client pays the invoice, then retries with an `Authorization: L402 macaroon:preimage` header. The backend routes show a balance model where a prepaid credential can be reused across protected endpoints until its credit is spent or the credential expires.
That is different from a monthly SaaS login. It lets an agent buy access to a capability, hold a credential and spend against it. The OpenAPI spec exposes balance checks, custom prepaid amounts through `amountSats`, and paid endpoints such as the Pull agent, chapter search, clip generation and on-demand transcription. The pricing constants in the backend set examples such as $0.10 for a Pull call, $0.05 for a clip and $0.45 for an on-demand transcription run, while small search primitives are much cheaper.
The security boundary is simple: an L402 credential is bearer-like. If an agent logs it, a browser extension leaks it or a shared notebook stores it, someone else may be able to spend the prepaid balance. Use small amounts first, avoid pasting credentials into broad tools and rotate them when a workflow changes.
Where NWC fits
NWC enters Jamie through payment automation, not through the podcast corpus itself. Alby's March 2026 article explains that the Jamie skill can use Alby CLI and a NWC connection so an agent can pay invoices and purchase credits. The backend repository depends on `@getalby/sdk`, and its Lightning utility code can use an NWC client to create invoices when an `NWC_CONNECTION_URI` is configured. NWC directories also list Jamie because it integrated Bitcoin Connect or NWC-style payments per prompt.
This is the pattern worth understanding: a research agent asks Jamie for work, Jamie requires payment for certain operations, the agent receives an L402 challenge, and a wallet connection can pay the Lightning invoice. Once paid, the agent retries with the L402 credential. NWC makes that flow programmable without handing the agent your whole wallet.
You should still be conservative. If you give an agent a NWC string, give it a dedicated wallet connection, a tiny budget and only the methods required for the task. Paying a Jamie invoice is one thing. Giving an open-ended agent the ability to pay arbitrary invoices is another. The quality of the research tool does not remove the need for wallet permission hygiene.
Nostr support is real but secondary
Jamie has Nostr code, but the public article should not inflate it into a general Nostr client. The React repository uses `nostr-tools` and has NIP-07 paths for signing and social sharing. Its README mentions creator tools that can work with Twitter and Nostr accounts. The backend includes services and models for Nostr mention watching, bot replies, zap watching, zap receipts and private zap decoding. Those are meaningful integration points.
They are also not the same as Nostr being the primary product. The main user value is still podcast search, research sessions and clips. Nostr appears where a creator wants to publish or monitor social activity, where the web app wants browser signing, and where backend automation can respond to mentions or zaps. That makes Jamie adjacent to Nostr's open social layer rather than a Nostr-native client.
For users, the practical check is key safety. If a Jamie flow asks to use a browser signer, confirm what event it signs. If a creator automation wants Nostr account access, use a signer or a scoped bot key instead of exposing a valuable personal secret. If a backend bot watches zaps or mentions, remember that relay coverage and event interpretation can be incomplete.
The web app is for research sessions
The React README describes Jamie's human-facing app as a place to search and analyze clips, explore a 3D galaxy of feeds, episodes, chapters and paragraphs, and save up to twenty moments into research sessions. Sessions can be shared, featured and analyzed. That is a useful shape for a researcher because the result is not just one answer. It is a collection of moments you can revisit.
Research sessions also reduce one of the common problems with AI search: losing the trail. If a model answer cites five moments, you want those moments grouped somewhere with links, timestamps and context. Jamie's session model gives a place to keep the work rather than repeating the same search later.
The limitation is still source review. A session can collect relevant passages, but it does not make every passage equally reliable or legally reusable. If you are writing, publishing or creating a clip, you still need to understand the episode context, speaker identity, copyright constraints and whether the clip fairly represents the conversation.
Clip creation turns search into media
Jamie can create MP4 clips with burned-in subtitles. The OpenAPI spec exposes `/api/make-clip` and a clip-status endpoint. The ClawHub skill references explain a workflow where you search for moments, choose timestamps, create a clip and poll until the result is ready. The backend README also describes media processing, subtitles and short-form clip rendering as part of the system.
This is valuable because podcast research often ends in a shareable moment. A transcript answer is useful for analysis, but a clip is what many people need for a post, a presentation or a source receipt. Jamie's ability to move from semantic search to timestamped clip creation is one of its strongest product loops.
It also raises practical risk. Generated clips can be misleading if timestamps are chosen too tightly. Subtitles can contain transcription errors. Podcast content may have licensing or fair-use constraints. Before publishing, listen to the clip, check the surrounding context and make sure the creator's terms allow the use you have in mind.
On-demand transcription fills gaps
The API also supports on-demand transcription and indexing. A user or agent can submit an episode for processing, poll job status and retrieve a transcript. The docs describe free quota paths for anonymous or registered users and L402 paths for paid machine access. That matters because no fixed corpus will cover every episode someone wants today.
On-demand transcription changes Jamie from a static search engine into a service that can ingest new material. If a researcher finds a missing RSS feed or a new episode that is not indexed, the tool can potentially process it and make it searchable. The ClawHub skill page presents this as one of the use cases for agents: ingest new feeds, then research them.
The caution is cost and time. On-demand transcription is more expensive than a search call, and processing may fail or take longer than a simple request. If you build automation around it, implement polling, failure handling, quotas and user confirmation before spending real credits.
The ClawHub skill is the agent packaging
The ClawHub page packages Jamie as a skill named PullThatUpJamie, version 1.6.0 when checked. It describes the skill as podcast intelligence over a semantic corpus and recommends using it instead of dumping long transcripts into a model. The skill supports free access without credentials and paid access through L402 Lightning credentials. It also names optional credential fields such as `NWC_CONNECTION_STRING` and `JAMIE_L402_CREDENTIAL`.
The backend repository includes a packaged skill directory with references for retrieve, research and analyze workflows, smart search behavior, clip creation and paid-tier usage. Those files are useful because they explain how an agent should think about requests: identify entities, feed filters, episode filters, date filters, count, topic, session intent, comparison, ingest intent and vague descriptive queries.
This packaging is part of Jamie's machine-web story. The web app is for humans, but the skill is for agents that need a repeatable way to call the service. If you are evaluating Jamie for an agent stack, read the skill references as carefully as the API schema.
Public code and licensing need care
Two public GitHub repositories were relevant during the June 2026 review. `uncleJim21/pullthatupjamie-react` is the React client, public TypeScript, with GitHub metadata showing GPL-3.0. `uncleJim21/pullthatupjamie-backend` is the backend, public JavaScript, also with GPL-3.0 in GitHub metadata. The backend package and OpenAPI strings also include ISC-style license metadata, so anyone reusing code should check the actual repository files and current license state rather than relying on one field.
The React repo shows the front-end product surface: 3D visualization, sessions, clip UI, creator routes, NIP-07 usage, nostr-tools, Bitcoin Connect remnants and the Jamie Pull agent client components. The backend repo shows the operational parts: Express routes, L402 challenge handling, pricing constants, macaroons, NWC invoice utilities, search services, clip services, on-demand processing and Nostr automation services.
That public code is a strong signal because it lets technical readers verify claims. It also means the product is evolving. The backend was pushed on June 12, 2026, and the React repo on June 9, 2026, when checked. Treat this article as a map for review, not as a frozen specification.
Privacy and data boundaries
Jamie touches several sensitive surfaces. Search queries reveal what you are researching. Research sessions can collect source moments around a theme. Clip creation may expose what you intend to publish. L402 credentials carry prepaid balances. NWC strings can authorize wallet actions. Nostr posting or sharing can tie research output to a public identity.
The safest practice is to separate contexts. Use the free tier or a small L402 credential for experiments. Use a dedicated NWC connection if an agent needs to pay. Avoid sending private personal research into shared sessions unless you understand how sharing works. If you use a Nostr signer, inspect each signature request. If you are a creator connecting social accounts, consider a bot or brand account rather than your primary personal identity.
Also remember that podcast transcripts are derived data. They can contain speaker errors, transcription errors, sensitive topics and copyrighted material. Jamie can help you find and clip, but it cannot decide the ethics of use for you. Source review remains part of the workflow.
How to test Jamie before relying on it
Start with the public app and a harmless search. Confirm that results contain feed, episode, timestamp or paragraph context. Then open `/api/corpus/stats` and `/api/corpus/spec` to see whether the corpus endpoints are healthy. Open `/api/openapi.json` if you plan to build, because it shows the exact request and response shapes better than a marketing page.
Next, test the machine path with the smallest useful amount. Call a paid endpoint without credentials and inspect the 402 challenge. If you choose to pay, use a small `amountSats` value, pay with a dedicated Lightning or NWC setup, then check `/api/agent/balance`. Do not start by funding a large balance or connecting a broadly permissioned wallet.
Finally, verify the source loop. Ask Jamie for a research answer, open the returned clips or hierarchy data, read adjacent paragraphs and listen to the audio. If the answer is for public writing, build a research session and keep the source links. The value of Jamie is speed to source, not permission to skip source checking.
What Jamie is not
Jamie is not a Nostr wallet. It can be part of an NWC payment flow, but it does not replace Alby Hub, Zeus, LNbits or another wallet service. Jamie is not an NWC node. It consumes Lightning payment rails for access and can use Alby SDK tooling, but the product is not a wallet backend.
Jamie is not a general Nostr client. It has NIP-07 and nostr-tools paths, and backend code around Nostr mentions, zaps and bot replies, but you do not use Jamie to manage a normal Nostr social feed. It is closer to an AI research product that can publish, monitor or accept payment in Nostr-adjacent ways.
Jamie is also not a universal truth engine for podcasts. It indexes, retrieves, summarizes and clips. That is powerful, but podcasts remain messy human conversations. The right posture is to let Jamie find the thread, then verify the fabric yourself.
The practical close
Pull that up, Jamie! is one of the clearer examples of where AI, Lightning and Nostr-adjacent tooling are converging. It takes a real pain point, podcast material that is hard to search, and turns it into a machine-readable research surface. Then it wraps paid access in L402 and Lightning so agents can pay for work without a conventional subscription account.
For readers, the useful mental model is simple: Jamie is a source-finding engine for spoken ideas. Use it when you need quotes, clips, guest appearances, topic trails or agent-ready podcast research. Respect the payment and identity boundaries because the system can touch wallets, public Nostr actions and creator accounts.
The strongest way to use Jamie is disciplined curiosity. Search broadly, collect carefully, pay with limits, keep credentials scoped and verify the moments before you quote or clip them. Done that way, Jamie can save hours without turning research into blind trust.
Sources worth opening
Start with the live site, llms.txt, OpenAPI file, corpus stats endpoint and Jamie Pull agent guide. Then open the React and backend repositories, because the code explains where Lightning, L402, NWC, NIP-07, clip creation, on-demand transcription and Nostr automation actually sit. The most useful external context is Alby's write-up about the Jamie skill, the ClawHub skill page, NWC documentation and NIP-47.
- Pull that up, Jamie! website
- Pull that up, Jamie! for agents page
- Pull that up, Jamie! llms.txt
- Pull that up, Jamie! OpenAPI schema
- Pull that up, Jamie! corpus stats
- Pull that up, Jamie! corpus specification
- Pull that up, Jamie! corpus feeds
- Jamie Pull Agent client guide
- Pull that up, Jamie! React repository
- Pull that up, Jamie! backend repository
- React README
- Backend README
- React package.json
- Backend package.json
- Jamie for agents React page
- Jamie Pull agent hook
- Jamie Pull agent message component
- Backend agent pricing constants
- Backend L402 macaroon utilities
- Backend Lightning and NWC utilities
- Backend agent routes
- Backend Pull agent service
- Backend agent tool handler
- Packaged Jamie ClawHub skill
- Jamie retrieve research analyze reference
- Jamie clip creation reference
- ClawHub PullThatUpJamie skill
- Alby blog on Pull That Up Jamie and Alby CLI skill
- Alby CLI repository
- Alby Agent Skill repository
- Alby MCP repository
- NWC official site
- NWC documentation
- NIP-47 Nostr Wallet Connect
- Bitcoin Connect repository
- L402 protocol documentation
- lnget repository
- Nostr NIP-07 browser signer
- nostr-tools repository
- NWC ecosystem website listing
- Pull that up, Jamie! privacy page
- Pull that up, Jamie! terms page
