Why a “Second Brain” for AI Agents Is the Infrastructure Bet Creators Should Care About
Every creator I know who’s leaned into AI agents—Claude Code, Codex, custom GPTs pulling from a knowledge base—has hit the same wall: the agent forgets what it did last week. You build a pristine workflow for batch-writing Instagram carousels, and next Monday the model recommends a hook you already scrapped because it can’t see the reasoning you stored in a Google Doc that your human teammate never tagged. The tools we use to store context—Notion, Google Docs, Obsidian—were designed for human reading and human writing. They assume the user is a person who opens a browser and types. But more and more of my content pipeline runs through an agent that writes to disk in markdown, then I review, remix, and ship. The friction isn’t in the writing anymore; it’s in the gap between the agent’s working memory and the team’s shared knowledge. That gap is exactly what Liminal tries to bridge. It’s a shared workspace that lives on your local disk, syncs to the cloud, and treats markdown files as the native language for both humans and agents. For a creator operation that runs on AI-driven scripting, repurposing, and research, that local-first, agent-friendly design could be the infrastructure we didn’t know we needed—but I have plenty of questions about whether it’s ready for the messiness of real social teams.
The Problem Liminal Actually Solves (and It’s Real)
If you’ve spent any time inside Claude Code or a similar coding agent, you know the drill: you feed it a prompt, it generates a reply, and that reply evaporates the moment you start a new thread unless you explicitly save it. The maker of Liminal, Justin Lam, describes exactly this dynamic in his Product Hunt launch post:
“Claude Code became my main interface, the intelligence layer everything flowed through. My job shifted from writing and producing to directing an agent to do it. Notion and Google Docs weren’t built for this.”
That line hits home. I’ve spent the last six months running a small content operation where I use an agent to draft LinkedIn long-form posts, repurpose YouTube transcripts into Twitter threads, and generate Pinterest pin descriptions. Every time I finish a batch, I paste the reasoning—why this hook worked, which keywords the platform is boosting—into a Notion page. But the agent never reads that page unless I explicitly paste its content into the next prompt. Context is lost with every session reset. The result: I rewrite the same decisions, and my team members who use different agents (or no agents) can’t access my notes without me manually exporting them.
Liminal solves this by making local markdown files the canonical storage format. Your agent writes to disk; Liminal renders those files as a clean WYSIWYG interface in a browser. A lightweight CLI watches the workspace folder and syncs bidirectionally with the cloud. When my agent saves a file called instagram-hooks-this-week.md, my teammate can open a link and see the live version, and their edits land back on my disk instantly. No MCP round-trips, no API tax, no proprietary format lock-in.
This is not a hypothetical workflow for creators. Anyone who uses AI to generate batches of content—calendar planks, hook variations, SEO meta descriptions—will eventually hit the problem of “where do I put this so the agent can find it later?” Notion and Google Docs require the agent to call an API that is slow and expensive. Liminal’s answer is dirt simple: put it on the local filesystem, where the agent already lives.
How It Differs from the Incumbents (and Why That Matters for Social Teams)
The Notion/Google Docs Trap
Notion and Google Docs are excellent for human collaboration. But they are terrible for agent collaboration. Their APIs add latency, cost tokens, and require custom integrations. Justin Lam calls this the “MCP tax”—the overhead of having your agent talk to a service via Model Context Protocol. In my own tests, asking an agent to write to a Notion database via API added 30–50% more time per operation and frequently broke when rate limits kicked in during batch content generation. Liminal’s approach—direct file access—eliminates that tax. The agent writes a .md file; the CLI syncs it. That’s it.
The VS Code Problem
If you’ve tried to live in VS Code as a non-coder, you know the pain: raw markdown preview is clunky. You toggle between edit and preview panes. You can’t nicely embed images without HTML. Sharing a .md file with a client or a designer is a non-starter. Liminal provides a browser-based WYSIWYG editor that renders the markdown as a clean interface, but the underlying file is still plain text. That’s a meaningful improvement for creators who need to collaborate with non-technical team members (client, editor, manager) without forcing them into VS Code.
The Obsidian / Local-First Comparison
Obsidian is the closest existing tool to this concept: local markdown files, graph view, plugin ecosystem. But Obsidian doesn’t natively support real-time multi-user collaboration on the same file. You can sync via a third-party service (iCloud, Git) but conflict resolution is manual and wonky. Liminal’s CLI handles bidirectional sync with conflict resolution in the UI. When two agents write to the same file, Liminal surfaces a diff per file and lets humans (or eventually agents) resolve it. That’s a meaningful step beyond Obsidian for a team that has multiple agents (or humans) writing into the same knowledge base.
However, Liminal is not a note-taking app in the traditional sense. It has no search, no graph view, no tagging system out of the box. Justin Lam’s response to a comment from Omri Ben-Shoham is telling:
“It turns out that LLMs are amazing at search already, and giving agents the ability to just grep your entire workspace is pretty effective even when you have hundreds or thousands of files! So today Liminal has no separate search capabilities and I believe that AI model companies will build better search faster than I can.”
That’s a bet, not a feature. For a creator with 50 files of content research, agent grep might be fine. For a team managing 500 files across months, I’d want structured search—and that’s missing today.
What Creators Can Borrow from Liminal’s Philosophy
Even if you don’t adopt the tool itself, the workflow it enables is worth replicating. Here’s what I’ve started doing in my own setup:
Decouple your agent’s output storage from your presentation layer. I now write agent-generated drafts to a local folder of markdown files, then use a static site generator to render them as a private dashboard. That lets me review, edit, and share without the agent touching a cloud API.
Treat markdown as the interchange format. I used to dump agent output into Google Docs. Now I keep it in
.mdand only convert to.docxwhen I need to send a final version to a client. The agent can read and write markdown natively; proprietary formats add friction.Use a sync layer that works offline. Liminal’s local-first approach means you can work on a plane, your agent can write files, and everything syncs when you reconnect. For creators who travel or work in low-connectivity environments, that’s a big deal.
Give every agent on your team a shared directory. If you have one agent for scripting, one for research, one for repurposing, put them all in the same workspace. They can read each other’s outputs without needing to be explicitly prompted. This is the “shared second brain” hypothesis—and it’s the most innovative part of Liminal.
Where My Judgment Says It Falls Short
I want to be direct: Liminal is a very early product. Justin Lam himself calls it “the first cut” and says he’s launching to find out if the friction is real for other people. That honesty earns trust, but it also means the tool has significant limitations for a creator or social media team today.
No Search, No Organization
As I noted, search is entirely delegated to the agent’s ability to grep. That works when you have a small number of files and you know the exact filename or keyword. But in a real content operation, you’re not just searching for a string—you’re trying to find “the post about Q4 strategy that used the callback to the Feb video.” An LLM can do fuzzy retrieval, but without a proper index, it will miss subtle connections. Tools like Notion AI and Mem have built neural search. Liminal doesn’t yet.
Permissions Are Promised but Not Fully Baked
A commenter Gal Dayan raised a crucial point: in a shared workspace with agents writing files, how do you prevent an agent from accidentally exposing sensitive client data? Justin Lam responded that Liminal has “per file access controls, just like Notion or Google Docs,” and that users can have personal workspaces. But when asked whether new files inherit folder permissions or default to private, he didn’t have a canned answer—he said the agent maker would need to be careful. For a social media team that handles brand calendars, unpublished campaigns, or confidential performance data, this is a gap. I’d want to see explicit default-to-private behavior before trusting an agent to write into a shared space.
Conflict Resolution Is Still Human-Led
When two agents write to the same file, Liminal shows a diff per file and asks the human to resolve it. That’s better than last-write-wins, but for a high-frequency content pipeline—say, a team of three agents generating 100 variants of hooks per hour—human conflict resolution becomes a bottleneck. Justin Lam says the next step is to make agents handle conflict resolution themselves. That’s a critical feature, and until it ships, Liminal scales poorly for agent-heavy workflows.
No Direct Integration with Social Platforms or Analytics
This is where the creator-specific lens matters. Liminal is a generic collaborative workspace. It doesn’t connect to Buffer, Hootsuite, Later, or any scheduling tool. It doesn’t pull engagement metrics or watch time data. You can’t use it to auto-schedule posts or run A/B tests. For a full-time content operator, Liminal solves one piece of the puzzle (knowledge management) but leaves the rest of the tech stack untouched. That’s fine if you already have a scheduling stack; it’s a non-starter if you were hoping for an all-in-one.
Who Is Liminal NOT For?
Right now, Liminal is for individuals and small teams who are already living inside Claude Code or Codex and who are comfortable with markdown, CLI tools, and a certain amount of tinkering. If you’re a creator who primarily uses Canva for design and CapCut for video editing, and you only occasionally use ChatGPT for captions, this tool will feel foreign. If your team has non-technical editors who expect a polished UI with drag-and-drop and rich media, Liminal’s barebones browser editor won’t win them over. And if you manage a large social media team with strict access control requirements, the current permission model is too opaque for comfort.
Why TikTok Creators Should Care More Than LinkedIn Ones
Let me zoom in on one audience segment: TikTok creators who use AI to script, script variations, and track trends. The TikTok algorithm rewards rapid iteration and deep understanding of what’s working. An agent that can read all your previous scripts, analyze comment sentiment, and suggest new hooks is powerful—but only if it has continuous access to that history. TikTok creators who run high-volume output (5+ posts per day) will benefit most from Liminal’s local-first, agent-friendly model because they can keep the agent’s context window small and rely on the file system for long-term memory. LinkedIn creators, by contrast, tend to write fewer, longer-form posts and often collaborate with human editors in real time. Their collaboration needs are better served by Google Docs’ native commenting and suggestion mode. Liminal’s killer use case is high-frequency, agent-driven content production—and that’s much more common on TikTok, Instagram Reels, and YouTube Shorts than on LinkedIn.
What I’d Watch / Test Next
I’m going to spin up a test workspace this week. Here’s my concrete next-step plan, and I’d recommend the same to any creator or social media operator who’s curious:
- Create a dedicated workspace folder for all agent-generated content drafts. Point my primary agent (Claude Code) to write all outputs there.
- Test the offline workflow: write a batch of five Instagram caption variations while I’m on a train, then sync with my teammate when I reconnect. See if conflict resolution is as smooth as claimed.
- Simulate a multi-agent collision: have two agents (Claude Code and a GPT wrapper) write to the same file simultaneously. Monitor how Liminal surfaces the diff and whether the UI-based resolution is fast enough for a live schedule.
- Check the permission defaults: create a new file via agent, then try to access it from a shared link. Confirm whether it inherits folder permissions or stays private. If it defaults to private, that’s a win; if it defaults to the folder’s permissions, I need to be very precise about where the agent writes.
Long-term, I want to see Liminal (or a competitor) add lightweight search that doesn’t require agent grep, automated conflict resolution, and native integrations with scheduling tools like Buffer or Metricool. The vision of a shared second brain for agents and humans is compelling, but for it to become part of a creator’s daily stack, the tool needs to meet us where our existing workflows already run. Justin Lam is asking the right questions, and I hope the community’s feedback pushes him toward the creator use case. Until then, Liminal is a promising experiment for the early-adopter crowd—not yet a must-have, but a signal of where the infrastructure is heading.
