deepagents-cli 0.0.37__tar.gz → 0.0.38__tar.gz

{deepagents_cli-0.0.37 → deepagents_cli-0.0.38}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.0.38](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.37...deepagents-cli==0.0.38) (2026-04-15)
+
+
+### Features
+
+* **cli:** user scoped memory ([#2708](https://github.com/langchain-ai/deepagents/issues/2708)) ([23bfca6](https://github.com/langchain-ai/deepagents/commit/23bfca6e46e6f3e4fba6657d858ddd5a0b06626f))
+
+
+### Bug Fixes
+
+* **deepagents:** remove old integration tests ([#2728](https://github.com/langchain-ai/deepagents/issues/2728)) ([6653197](https://github.com/langchain-ai/deepagents/commit/6653197b6cbec6dd1ca23d9f90bc1439ca26e6e5))
+
+
+### Performance Improvements
+
+* **cli:** `O(1)` message lookups in `MessageStore` ([#2350](https://github.com/langchain-ai/deepagents/issues/2350)) ([d39fd5d](https://github.com/langchain-ai/deepagents/commit/d39fd5d3651fd87d1eea8c02cbef2c2f62449e67))
+
 ## [0.0.37](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.36...deepagents-cli==0.0.37) (2026-04-10)
 
 ### Features

{deepagents_cli-0.0.37 → deepagents_cli-0.0.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.37
+Version: 0.0.38
 Summary: Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities.
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/
@@ -27,7 +27,7 @@ Classifier: Topic :: Terminals
 Requires-Python: <4.0,>=3.11
 Requires-Dist: aiosqlite<1.0.0,>=0.19.0
 Requires-Dist: deepagents-acp>=0.0.4
-Requires-Dist: deepagents==0.5.2
+Requires-Dist: deepagents==0.5.3
 Requires-Dist: httpx<1.0.0,>=0.28.1
 Requires-Dist: langchain-anthropic<2.0.0,>=1.4.0
 Requires-Dist: langchain-google-genai<5.0.0,>=4.2.1

{deepagents_cli-0.0.37 → deepagents_cli-0.0.38}/deepagents_cli/_version.py

@@ -1,6 +1,6 @@
 """Version information and lightweight constants for `deepagents-cli`."""
 
-__version__ = "0.0.37"  # x-release-please-version
+__version__ = "0.0.38"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/cli"
 """URL for `deepagents-cli` documentation."""

{deepagents_cli-0.0.37 → deepagents_cli-0.0.38}/deepagents_cli/app.py

@@ -1505,11 +1505,15 @@ class DeepAgentsApp(App):
 
         try:
             from deepagents_cli._version import __version__ as cli_version
+            from deepagents_cli.config import _is_editable_install
+
+            if await asyncio.to_thread(_is_editable_install):
+                heading = f"Now running v{cli_version}"
+            else:
+                heading = f"Updated to v{cli_version}"
 
             await self._mount_message(
-                AppMessage(
-                    f"Updated to v{cli_version}\nSee what's new: {CHANGELOG_URL}"
-                )
+                AppMessage(f"{heading}\nSee what's new: {CHANGELOG_URL}")
             )
         except Exception:
             logger.debug("What's new banner display failed", exc_info=True)

{deepagents_cli-0.0.37 → deepagents_cli-0.0.38}/deepagents_cli/deploy/bundler.py

@@ -9,9 +9,16 @@ Reads the canonical project layout:
     .env             # optional — environment variables
     mcp.json         # optional — HTTP/SSE MCP servers
     skills/          # optional — auto-seeded into skills namespace
+    user/            # optional — per-user writable memory
+        AGENTS.md    # optional — seeded as empty if not provided
 ```
 
 ...and writes everything `langgraph deploy` needs to a build directory.
+
+AGENTS.md and skills are read-only at runtime.  When a ``user/``
+directory is present, a per-user ``AGENTS.md`` is seeded (from
+``user/AGENTS.md`` if provided, otherwise empty) and is writable
+at runtime.
 """
 
 from __future__ import annotations
@@ -25,6 +32,7 @@ from deepagents_cli.deploy.config import (
     AGENTS_MD_FILENAME,
     MCP_FILENAME,
     SKILLS_DIRNAME,
+    USER_DIRNAME,
     DeployConfig,
 )
 from deepagents_cli.deploy.templates import (
@@ -75,9 +83,10 @@ def bundle(
         encoding="utf-8",
     )
     logger.info(
-        "Wrote _seed.json (memories: %d, skills: %d)",
+        "Wrote _seed.json (memories: %d, skills: %d, user_memories: %d)",
         len(seed["memories"]),
         len(seed["skills"]),
+        len(seed.get("user_memories", {})),
     )
 
     # 3. Copy mcp.json if present.
@@ -96,8 +105,13 @@ def bundle(
         logger.info("Copied %s → .env", env_src)
 
     # 4. Render deploy_graph.py.
+    has_user_memories = (project_root / USER_DIRNAME).is_dir()
     (build_dir / "deploy_graph.py").write_text(
-        _render_deploy_graph(config, mcp_present=mcp_present),
+        _render_deploy_graph(
+            config,
+            mcp_present=mcp_present,
+            has_user_memories=has_user_memories,
+        ),
         encoding="utf-8",
     )
     logger.info("Generated deploy_graph.py")
@@ -121,32 +135,25 @@ def _build_seed(
     config: DeployConfig,  # noqa: ARG001
     project_root: Path,
     system_prompt: str,
-) -> dict[str, dict[str, str]]:
+) -> dict:
     """Build the `_seed.json` payload.
 
-    Layout:
-
-    ```txt
-    {
-        "memories": { "/AGENTS.md": "..." },
-        "skills":   { "/<skill>/SKILL.md": "...", ... }
-    }
-    ```
+    Layout::
 
-    `memories` always contains `/AGENTS.md` — the middleware loads it at
-    startup via `/memories/AGENTS.md`. Agent reads of `/memories/` and
-    `/skills/` are denied by `FilesystemPermission` rules.
+        {
+            "memories":       { "/AGENTS.md": "..." },
+            "skills":         { "/<skill>/SKILL.md": "...", ... },
+            "user_memories":  { "/AGENTS.md": "..." }
+        }
 
-    `skills` walks `skills/` if present. Keys are paths relative to the
-    skills dir with a leading slash; the runtime namespace handles the
-    scoping.
+    ``memories`` and ``skills`` are read-only at runtime.
+    ``user_memories`` contains a single writable ``AGENTS.md`` mounted at
+    ``/memories/user/``, namespaced per user_id.  If the project has a
+    ``user/`` directory (even if empty), an ``AGENTS.md`` is always seeded.
     """
-    # Keys must match what CompositeBackend passes to the mounted
-    # StoreBackend after stripping the route prefix: for a read of
-    # /memories/AGENTS.md it calls store.read("/AGENTS.md").
-    # Seed with the same leading-slash convention.
     memories: dict[str, str] = {f"/{AGENTS_MD_FILENAME}": system_prompt}
     skills: dict[str, str] = {}
+    user_memories: dict[str, str] = {}
 
     skills_dir = project_root / SKILLS_DIRNAME
     if skills_dir.is_dir():
@@ -155,13 +162,28 @@ def _build_seed(
                 rel = f.relative_to(skills_dir).as_posix()
                 skills[f"/{rel}"] = f.read_text(encoding="utf-8")
 
-    return {"memories": memories, "skills": skills}
+    user_dir = project_root / USER_DIRNAME
+    if user_dir.is_dir():
+        user_agents_md = user_dir / AGENTS_MD_FILENAME
+        content = (
+            user_agents_md.read_text(encoding="utf-8")
+            if user_agents_md.is_file()
+            else ""
+        )
+        user_memories[f"/{AGENTS_MD_FILENAME}"] = content
+
+    return {
+        "memories": memories,
+        "skills": skills,
+        "user_memories": user_memories,
+    }
 
 
 def _render_deploy_graph(
     config: DeployConfig,
     *,
     mcp_present: bool,
+    has_user_memories: bool = False,
 ) -> str:
     """Render the generated `deploy_graph.py`."""
     provider = config.sandbox.provider
@@ -186,6 +208,7 @@ def _render_deploy_graph(
         mcp_tools_block=mcp_tools_block,
         mcp_tools_load_call=mcp_tools_load_call,
         default_assistant_id=config.agent.name,
+        has_user_memories=has_user_memories,
     )
 
 
@@ -256,6 +279,12 @@ def print_bundle_summary(config: DeployConfig, build_dir: Path) -> None:
         for f in memory_files:
             print(f"    {f}")
 
+    user_memory_files = sorted(seed.get("user_memories", {}).keys())
+    if user_memory_files:
+        print(f"\n  User memory seed ({len(user_memory_files)} file(s)):")
+        for f in user_memory_files:
+            print(f"    {f}")
+
     skills_files = sorted(seed.get("skills", {}).keys())
     if skills_files:
         print(f"\n  Skills seed ({len(skills_files)} file(s)):")

{deepagents_cli-0.0.37 → deepagents_cli-0.0.38}/deepagents_cli/deploy/config.py

@@ -41,6 +41,7 @@ DEFAULT_CONFIG_FILENAME = "deepagents.toml"
 # Canonical filenames inside the project root.
 AGENTS_MD_FILENAME = "AGENTS.md"
 SKILLS_DIRNAME = "skills"
+USER_DIRNAME = "user"
 MCP_FILENAME = "mcp.json"
 
 

{deepagents_cli-0.0.37 → deepagents_cli-0.0.38}/deepagents_cli/deploy/templates.py

@@ -3,10 +3,13 @@
 These templates are rendered by the bundler with values from
 `~deepagents_cli.deploy.config.DeployConfig`.
 
-The generated `deploy_graph.py` uses a `CompositeBackend` with two
-`StoreBackend` routes (memories and skills) and the configured sandbox
-as the default writable backend.  Write access to `/memories/` and
-`/skills/` is denied via ``FilesystemPermission`` rules.
+The generated ``deploy_graph.py`` uses a ``CompositeBackend`` with all
+managed content under ``/memories/`` — ``/memories/AGENTS.md``,
+``/memories/skills/``, and ``/memories/user/`` (per-user templates) —
+backed by ``StoreBackend`` instances.  The configured sandbox is the
+default writable backend.  Write access is controlled via
+``FilesystemPermission`` rules derived from each file's YAML frontmatter
+``permissions`` field.
 
 There is no hub path and no custom Python tools.
 """
@@ -196,21 +199,28 @@ async def _load_mcp_tools():
 # ---------------------------------------------------------------------------
 # deploy_graph.py — the generated server entry point
 #
-# Store layout (CompositeBackend with sandbox default + two read-only routes):
+# Store layout (CompositeBackend with sandbox default + routed stores):
 #
-#   Mount          Namespace                         Writable
-#   -------------  --------------------------------  --------
-#   /memories/     (assistant_id, "memories")        no
-#   /skills/       (assistant_id, "skills")          no
-#   default        sandbox (per `[sandbox].scope`)    yes
+#   Mount              Namespace                                   Writable
+#   -----------------  ------------------------------------------  --------
+#   /memories/user/    (assistant_id, user_id)   yes  [user AGENTS.md]
+#   /memories/skills/  (assistant_id,)           no
+#   /memories/         (assistant_id,)           no   [AGENTS.md]
+#   default            sandbox (per scope)       yes
 #
 # `make_graph` takes the `RunnableConfig` at factory time, pulls
 # `assistant_id` from `config["configurable"]`, and uses it as the
 # top-level namespace component so different assistants built from the
 # same graph have isolated memories and skills.
 #
-# The bundler ships `_seed.json` containing both payloads; the factory
-# seeds each namespace once per (process, assistant_id).
+# User memories are namespaced per (assistant_id, user_id) so each
+# user gets their own copy.  Template files are seeded on first access
+# (only if not already present).  Write access is controlled per-file
+# via frontmatter ``permissions: read-write`` declarations.
+#
+# The bundler ships `_seed.json` containing all payloads; the factory
+# seeds each namespace once per (process, assistant_id) and user
+# memories once per (process, assistant_id, user_id).
 # ---------------------------------------------------------------------------
 
 DEPLOY_GRAPH_TEMPLATE = '''\
@@ -251,8 +261,13 @@ SANDBOX_TEMPLATE = {sandbox_template!r}
 SANDBOX_IMAGE = {sandbox_image!r}
 
 # Mount points inside the composite backend.
+# Everything lives under /memories/ — longest-prefix-first routing
+# ensures /memories/user/ and /memories/skills/ match before /memories/.
 MEMORIES_PREFIX = "/memories/"
-SKILLS_PREFIX = "/skills/"
+SKILLS_PREFIX = "/memories/skills/"
+USER_PREFIX = "/memories/user/"
+
+HAS_USER_MEMORIES = {has_user_memories!r}
 
 # What to seed into the store on first run.
 SEED_PATH = Path(__file__).parent / "_seed.json"
@@ -346,19 +361,22 @@ def _load_seed() -> dict:
     if _SEED_CACHE is not None:
         return _SEED_CACHE
     if not SEED_PATH.exists():
-        _SEED_CACHE = {{"memories": {{}}, "skills": {{}}}}
+        _SEED_CACHE = {{"memories": {{}}, "skills": {{}}, "user_memories": {{}}}}
         return _SEED_CACHE
     try:
         _SEED_CACHE = json.loads(SEED_PATH.read_text(encoding="utf-8"))
     except Exception as exc:  # noqa: BLE001
         logger.warning("Failed to parse _seed.json: %s", exc)
-        _SEED_CACHE = {{"memories": {{}}, "skills": {{}}}}
+        _SEED_CACHE = {{"memories": {{}}, "skills": {{}}, "user_memories": {{}}}}
     return _SEED_CACHE
 
 
 # Per-(process, assistant_id) gate.
 _SEEDED_ASSISTANTS: set[str] = set()
 
+# Per-(process, assistant_id, user_id) gate for user memories.
+_SEEDED_USERS: set[tuple[str, str]] = set()
+
 
 async def _seed_store_if_needed(store, assistant_id: str) -> None:
     """Seed memories + skills under ``assistant_id`` once per process."""
@@ -368,7 +386,7 @@ async def _seed_store_if_needed(store, assistant_id: str) -> None:
 
     seed = _load_seed()
 
-    memories_ns = (assistant_id, "memories")
+    memories_ns = (assistant_id,)
     for path, content in seed.get("memories", {{}}).items():
         if await store.aget(memories_ns, path) is None:
             await store.aput(
@@ -377,7 +395,7 @@ async def _seed_store_if_needed(store, assistant_id: str) -> None:
                 {{"content": content, "encoding": "utf-8"}},
             )
 
-    skills_ns = (assistant_id, "skills")
+    skills_ns = (assistant_id,)
     for path, content in seed.get("skills", {{}}).items():
         if await store.aget(skills_ns, path) is None:
             await store.aput(
@@ -387,15 +405,67 @@ async def _seed_store_if_needed(store, assistant_id: str) -> None:
             )
 
 
+async def _seed_user_memories_if_needed(
+    store, assistant_id: str, user_id: str,
+) -> None:
+    """Seed user memory templates once per (assistant_id, user_id).
+
+    Only writes entries that do not yet exist in the store, so
+    user-modified memories are never overwritten.
+    """
+    key = (assistant_id, user_id)
+    if key in _SEEDED_USERS:
+        return
+    _SEEDED_USERS.add(key)
+
+    seed = _load_seed()
+    user_memories = seed.get("user_memories", {{}})
+    if not user_memories:
+        return
+
+    user_ns = (assistant_id, user_id)
+    for path, content in user_memories.items():
+        if await store.aget(user_ns, path) is None:
+            await store.aput(
+                user_ns,
+                path,
+                {{"content": content, "encoding": "utf-8"}},
+            )
+    logger.info(
+        "Seeded %d user memory template(s) for user %s",
+        len(user_memories),
+        user_id,
+    )
+
+
 {sandbox_block}
 
 {mcp_tools_block}
 
 
-def _make_namespace_factory(assistant_id: str, section: str):
-    """Return a namespace factory closed over an assistant id + section."""
+def _make_namespace_factory(assistant_id: str, *extra: str):
+    """Return a namespace factory closed over an assistant id + extra."""
+    ns = (assistant_id, *extra)
     def _factory(ctx):  # noqa: ARG001
-        return (assistant_id, section)
+        return ns
+    return _factory
+
+
+def _make_user_namespace_factory(assistant_id: str):
+    """Return a namespace factory that includes the user_id.
+
+    Uses ``rt.server_info.user.identity`` from custom auth.  The platform
+    always injects user_id from auth, so no configurable fallback is needed.
+    """
+    def _factory(rt):
+        user = getattr(rt.server_info, "user", None) if rt.server_info else None
+        identity = getattr(user, "identity", None) if user else None
+        if not identity:
+            raise ValueError(
+                "user_id is required when user memories are enabled. "
+                "Set it via custom auth (runtime.user.identity)."
+            )
+        return (assistant_id, str(identity))
     return _factory
 
 
@@ -413,16 +483,24 @@ def _build_backend_factory(assistant_id: str):
             thread_id = get_config().get("configurable", {{}}).get("thread_id", "local")
             cache_key = f"thread:{{thread_id}}"
         sandbox_backend = _get_or_create_sandbox(cache_key)
+
+        routes = {{
+            MEMORIES_PREFIX: StoreBackend(
+                namespace=_make_namespace_factory(assistant_id),
+            ),
+            SKILLS_PREFIX: StoreBackend(
+                namespace=_make_namespace_factory(assistant_id),
+            ),
+        }}
+
+        if HAS_USER_MEMORIES:
+            routes[USER_PREFIX] = StoreBackend(
+                namespace=_make_user_namespace_factory(assistant_id),
+            )
+
         return CompositeBackend(
             default=sandbox_backend,
-            routes={{
-                MEMORIES_PREFIX: StoreBackend(
-                    namespace=_make_namespace_factory(assistant_id, "memories"),
-                ),
-                SKILLS_PREFIX: StoreBackend(
-                    namespace=_make_namespace_factory(assistant_id, "skills"),
-                ),
-            }},
+            routes=routes,
         )
     return _factory
 
@@ -430,36 +508,58 @@ def _build_backend_factory(assistant_id: str):
 async def make_graph(config: RunnableConfig, runtime: "ServerRuntime"):
     """Async graph factory.
 
-    Accepts the invocation's ``RunnableConfig`` so we can pull the
-    ``assistant_id`` out of ``configurable`` and scope all store reads
-    and writes under it. Seeds the memories + skills namespaces once per
-    (process, assistant_id), then assembles the deep agent graph.
+    Accepts the invocation's ``RunnableConfig`` for ``assistant_id`` and
+    the ``ServerRuntime`` for ``store`` and ``user.identity``.  Seeds
+    memories + skills once per (process, assistant_id), and user memories
+    once per (process, assistant_id, user_id).  Gracefully skips user
+    memory features when no user_id is available.
     """
     configurable = (config or {{}}).get("configurable", {{}}) or {{}}
     assistant_id = str(configurable.get("assistant_id") or {default_assistant_id!r})
 
     store = getattr(runtime, "store", None)
+    user_id = None
+    if HAS_USER_MEMORIES:
+        user = getattr(runtime, "user", None)
+        identity = getattr(user, "identity", None) if user else None
+        user_id = str(identity) if identity else None
+    if HAS_USER_MEMORIES and not user_id:
+        logger.warning(
+            "User memories are enabled but no user_id found "
+            "(runtime.user.identity is empty). User memory features "
+            "will be skipped for this invocation."
+        )
     if store is not None:
         await _seed_store_if_needed(store, assistant_id)
+        if HAS_USER_MEMORIES and user_id:
+            await _seed_user_memories_if_needed(store, assistant_id, user_id)
 
     tools: list = []
     {mcp_tools_load_call}
 
     backend_factory = _build_backend_factory(assistant_id)
 
+    # Preload AGENTS.md + user memory into the agent's context.
+    memory_sources = [f"{{MEMORIES_PREFIX}}AGENTS.md"]
+    if HAS_USER_MEMORIES and user_id:
+        memory_sources.append(f"{{USER_PREFIX}}AGENTS.md")
+
+    # AGENTS.md and skills are read-only; user memories are writable.
+    permissions = [
+        FilesystemPermission(
+            operations=["write"],
+            paths=[f"{{MEMORIES_PREFIX}}AGENTS.md", f"{{SKILLS_PREFIX}}**"],
+            mode="deny",
+        ),
+    ]
+
     return create_deep_agent(
         model={model!r},
-        memory=[f"{{MEMORIES_PREFIX}}AGENTS.md"],
+        memory=memory_sources,
         skills=[SKILLS_PREFIX],
         tools=tools,
         backend=backend_factory,
-        permissions=[
-            FilesystemPermission(
-                operations=["write"],
-                paths=["/memories/**", "/skills/**"],
-                mode="deny",
-            ),
-        ],
+        permissions=permissions,
         middleware=[
             SandboxSyncMiddleware(backend=backend_factory, sources=[SKILLS_PREFIX]),
         ],

{deepagents_cli-0.0.37 → deepagents_cli-0.0.38}/deepagents_cli/widgets/message_store.py

@@ -375,6 +375,13 @@ class MessageStore:
     def __init__(self) -> None:
         """Initialize the message store."""
         self._messages: list[MessageData] = []
+        self._index: dict[str, MessageData] = {}
+        """ID -> MessageData lookup.
+
+        Must contain exactly one entry per element of `_messages`. Any method
+        that adds to or removes from `_messages` must update `_index`
+        in lockstep.
+        """
         self._visible_start: int = 0
         self._visible_end: int = 0
 
@@ -407,7 +414,14 @@ class MessageStore:
         Args:
             message: The message data to add.
         """
+        if message.id in self._index:
+            logger.warning(
+                "Duplicate message ID %r appended; previous entry will be "
+                "unreachable via get_message()",
+                message.id,
+            )
         self._messages.append(message)
+        self._index[message.id] = message
         self._visible_end = len(self._messages)
 
     def bulk_load(
@@ -426,6 +440,14 @@ class MessageStore:
             Tuple of (archived, visible) message lists.
         """
         self._messages.extend(messages)
+        for msg in messages:
+            if msg.id in self._index:
+                logger.warning(
+                    "Duplicate message ID %r in bulk_load; previous entry "
+                    "will be unreachable via get_message()",
+                    msg.id,
+                )
+            self._index[msg.id] = msg
         total = len(self._messages)
 
         if total <= self.WINDOW_SIZE:
@@ -448,10 +470,7 @@ class MessageStore:
         Returns:
             The message data, or None if not found.
         """
-        for msg in self._messages:
-            if msg.id == message_id:
-                return msg
-        return None
+        return self._index.get(message_id)
 
     def get_message_at_index(self, index: int) -> MessageData | None:
         """Get a message by its index.
@@ -488,12 +507,16 @@ class MessageStore:
             msg = f"Cannot update unknown or protected fields: {unknown}"
             raise ValueError(msg)
 
-        for msg_data in self._messages:
-            if msg_data.id == message_id:
-                for key, value in updates.items():
-                    setattr(msg_data, key, value)
-                return True
-        return False
+        msg_data = self._index.get(message_id)
+        if msg_data is None:
+            logger.warning(
+                "update_message called for unknown ID %r; update discarded",
+                message_id,
+            )
+            return False
+        for key, value in updates.items():
+            setattr(msg_data, key, value)
+        return True
 
     def set_active_message(self, message_id: str | None) -> None:
         """Set the currently active (streaming) message.
@@ -646,6 +669,7 @@ class MessageStore:
     def clear(self) -> None:
         """Clear all messages."""
         self._messages.clear()
+        self._index.clear()
         self._visible_start = 0
         self._visible_end = 0
         self._active_message_id = None

deepagents_cli-0.0.38/examples/deploy-content-writer/.env.example

@@ -0,0 +1,2 @@
+OPENAI_API_KEY=
+LANGSMITH_API_KEY=

deepagents_cli-0.0.38/examples/deploy-content-writer/skills/blog-post/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: blog-post
+description: Write long-form blog posts with SEO optimization and clear structure.
+---
+
+# Blog Post Writing
+
+Write blog posts that are informative, engaging, and optimized for search.
+
+## Structure
+
+1. **Title** — Clear, compelling, includes target keyword
+2. **Introduction** — Hook the reader, state the problem, preview the solution
+3. **Body** — 3-5 sections with headers, each making one clear point
+4. **Conclusion** — Summarize key takeaways, include a call to action

deepagents_cli-0.0.38/examples/deploy-content-writer/skills/social-media/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: social-media
+description: Create social media posts optimized for engagement across platforms.
+---
+
+# Social Media Content
+
+Create platform-appropriate social media posts.
+
+## Guidelines
+
+- Keep it concise and punchy
+- Lead with a hook
+- Include a clear call to action
+- Adapt tone per platform (LinkedIn vs Twitter vs etc.)

deepagents_cli-0.0.38/examples/deploy-content-writer/user/context.md

@@ -0,0 +1,15 @@
+---
+name: context
+description: Company and product context for content creation
+permissions: read
+---
+
+# Company Context
+
+Update this file with your company's specific context:
+
+- Company name and description
+- Product names and key features
+- Target audience details
+- Competitor landscape
+- Key differentiators

deepagents_cli-0.0.38/examples/deploy-content-writer/user/preferences.md

@@ -0,0 +1,11 @@
+---
+name: preferences
+description: User content preferences and style overrides
+permissions: read-write
+---
+
+# Content Preferences
+
+No preferences set yet. The agent will update this file as it learns
+about the user's preferred topics, tone adjustments, and formatting
+choices.