Results for “agent memory”

Expert in CrewAI - the leading role-based multi-agent framework used by 60% of Fortune 500 companies. Covers agent design with roles and goals, task definition, crew orchestration, process types (sequential, hierarchical, parallel), memory systems, and flows for complex workflows. Essential for building collaborative AI agent teams. Use when "crewai, multi-agent team, agent roles, crew of agents, role-based agents, collaborative agents, crewai, multi-agent, agents, orchestration, roles, collaborative-ai" mentioned.

The English summary is being prepared. Showing the original description.

Agent Memory Systems workflow skill. Use this skill when the user needs "Memory is the cornerstone of intelligent agents. Without it, every and the operator should preserve the upstream workflow, copied support files, and provenance before merging or handing off.

The English summary is being prepared. Showing the original description.

Agent Memory Skill workflow skill. Use this skill when the user needs A hybrid memory system that provides persistent, searchable knowledge management for AI agents (Architecture, Patterns, Decisions) and the operator should preserve the upstream workflow, copied support files, and provenance before merging or handing off.

The English summary is being prepared. Showing the original description.

Use when building durable AI agents or agentic workflows with Inngest and AgentKit, including model calls, tool calls, multi-agent networks, human approval, realtime progress, provider rate limits, crash-safe execution, and Agent Evals handoff. Covers AgentKit, `step.ai`, `step.run`, `step.waitForEvent`, native realtime, and when to use lower-level Inngest primitives instead of an in-memory agent loop. Use `inngest-agent-evals` with this skill when the user wants scoring, sessions, experiments, deferred scorers, or outcome-based evaluation for the agent.

The English summary is being prepared. Showing the original description.

End-of-session pass that persists durable facts from the CURRENT session into .claude/memory/. Runs IN-SESSION in the main agent (never via Task — a subagent starts cold with no transcript), prompted by the Stop hook's nudge. Triggers on "persist durable facts from this session", "run memory-extraction", "flush session memory", or "extract memory before close". Reads the in-context transcript plus existing memory, applies the durable-fact predicate below, and writes one file per fact plus one MEMORY.md index line — append-or-update, never clobbering a consumer's existing memory.

The English summary is being prepared. Showing the original description.

Use when designing evaluation suites for agentic systems, choosing agent benchmarks, measuring multi-agent performance, or critiquing single-score evaluation of agents. Based on arXiv:2605.26112v1. Trigger phrases: "evaluate my agent", "benchmark agent", "measure agent reliability", "pass^k evaluation", "agent metrics beyond success rate", "trajectory quality", "memory hygiene metric", "longitudinal agent eval", "why my agent scores well on benchmarks but fails in production".

The English summary is being prepared. Showing the original description.

Design a persistent multi-agent workflow in Claude Code, with specialist roles, reusable commands, file-based memory, and scheduled tasks. Keep project context and decisions across sessions using JSON and Markdown files without an external database.

• Coordinate specialist agents for development and writing
• Preserve project context across sessions
• Schedule recurring morning briefings

Build agent memory with Pinecone by storing searchable representations of conversations and documents. Retrieve relevant past context for answers, organize memory by session or user, and prototype semantic search that finds information by meaning.

• Building agent memory that persists across sessions
• Adding retrieved context to agent answers
• Organizing memory separately for each user

Initialize a group of collaborating AI agents by choosing how they connect, allocating resources, and setting up communication. Establish shared-memory rules so agents record progress, share outputs, check dependencies, and signal completion.

• Setting up an agent group for REST API development
• Configuring eight agents in a hierarchy for feature development
• Preparing a mesh of agents for distributed code analysis

Store useful patterns and solutions in AgentDB, then find them through semantic search, which matches meaning rather than exact wording. Use saved knowledge before starting work and record successful approaches and new lessons afterward.

• Saving successful approaches for reuse
• Finding solutions from past work
• Searching stored knowledge by meaning

Set up and operate Ruflo to coordinate multiple AI coding agents. This skill guides project initialization, shared memory, task assignment, health checks, and plugin discovery for work that needs coordinated or parallel execution.

• Initializing a multi-agent development environment
• Coordinating parallel work across agents
• Keeping searchable memory across sessions

Provides persistent project memory for AI agents through a local MCP server, a tool interface for agents. Stores and searches architecture decisions and implementation patterns, syncs with project documentation, and includes a dashboard for viewing memory usage.

• Save architecture decisions for later reference
• Search previously recorded implementation patterns
• Retrieve design notes by key

Write and review Rust, C++, and C code with safer memory and resource management. Covers ownership, automatic cleanup tied to scope, and smart pointers to help prevent leaks, double frees, and access to freed memory.

• Design safer memory management in systems code
• Review cleanup of files, sockets, and memory
• Investigate memory leaks and access to freed memory

Extend a NanoClaw agent's own environment with packages, external tools, or specialist agents. The skill chooses the workflow for each change, edits memory and standing instructions, and delegates source changes to a builder for review.

• Adding an external tool for reading RSS feeds
• Installing persistent system or global npm packages
• Updating memory or standing behavior instructions

Reconcile project documentation, agent rules, authorized memory, and workspace leftovers with current code and runtime behavior. Prepare a clear handoff by correcting stale information, identifying authoritative explanations, and reporting what is verified, pending, or awaiting cleanup approval.

• Synchronizing documentation after development
• Resolving stale or conflicting agent rule files
• Preparing a handoff to another person or a fresh session

Investigate crashes, out-of-memory errors, and device initialization failures on GKE TPU v6e nodes. The skill checks logs and custom metrics collection for conflicting operations, then guides temporary mitigation by disabling an identified collector.

• Investigate vbar_control_agent crashes and memory exhaustion
• Check tpu-device-plugin metrics checksum errors
• Inspect conflicts with custom TPU metrics collectors

Review an agent's saved context and unread coordination messages at the start of a task. Summarize relevant assignments, move handled messages aside, and prompt the agent to preserve lasting decisions and outcomes before finishing.

• Resume work using context saved in a previous session
• Check new messages and assignments for an agent
• Preserve decisions and outcomes for the next session

Review an agent’s saved memory alongside project and personal instructions. Receive proposed destinations for useful entries and a cleanup report covering duplicates, outdated facts, conflicts, and unclear items, with approval required before changes.

• Turning saved memory into shared project instructions
• Separating personal instructions from project conventions
• Finding duplicate or outdated memory

Coordinate multiple AI agents with agentic-flow to run tasks in parallel or through ordered stages. Configure shared memory, team structure, workload distribution, retries, and task reassignment, then monitor how the group performs.

• Run API, interface, and test work in parallel
• Build a design-to-review workflow with ordered stages
• Share specifications and state across agents

Review the file-based memory store via the Agent Monitor Config Explorer API: the user and project CLAUDE.md plus per-project auto-memory files under ~/.claude/projects/<slug>/memory/*.md. Groups by project, shows the index (MEMORY.md) vs per-fact files, and flags stale or oversized facts. Reads /api/cc-config/memory and /api/cc-config/file?path=. Use when curating agent memory.

The English summary is being prepared. Showing the original description.

Agent Memory Systems workflow skill. Use this skill when the user needs "Memory is the cornerstone of intelligent agents. Without it, every and the operator should preserve the upstream workflow, copied support files, and provenance before merging or handing off.

The English summary is being prepared. Showing the original description.

Use when modifying agentic contextual building blocks like skills (SKILL.md), slash commands, agents, hooks, plugins, marketplaces, and instruction files (CLAUDE.md, AGENTS.md, GEMINI.md, QWEN.md, Cursor, Copilot, Cline, or Kiro rules), tool configuration such as an OpenCode `opencode.json`, Muse Code hooks (`.muse/hooks.json`), a Grok Build `.grok/` project layer or a Google Antigravity customization root (`.agents/`, `.agent/`, `_agents/`, `_agent/` — hooks, MCP config, rules, registries and plugins), and committed project memory (`.agents/memory/`). Run skillsaw on the files you touched, apply autofixes, resolve remaining violations with `skillsaw explain` guidance, and re-lint until clean before considering the work complete.

The English summary is being prepared. Showing the original description.

Design Agentforce conversations that span multiple turns without losing context: session variable scoping, conversation memory, clarifying-question patterns, topic-to-topic (now subagent) handoff, and the right abstractions for accumulating state across turns. NOT for deciding the topic boundaries themselves or out-of-scope behavior — use agentforce/agent-topic-design. NOT for single-turn agent actions and their input/output contracts — use agentforce/agent-actions.

The English summary is being prepared. Showing the original description.

Use ruLake as the agent's working memory. Auto-invoke /rulake-memory:memory-recall when the agent needs to look up something it might already know; auto-invoke /rulake-memory:memory-remember after the agent learns or decides something worth pinning. Closes the self-learning loop without requiring the agent author to wire it explicitly.

The English summary is being prepared. Showing the original description.