In the Strands Agents SDK, context refers to the information provided to the agent for understanding and reasoning. This includes:

-   User messages
-   Agent responses
-   Tool usage and results
-   System prompts

As conversations grow, managing this context becomes increasingly important for several reasons:

1.  **Token Limits**: Language models have fixed context windows (maximum tokens they can process)
2.  **Performance**: Larger contexts require more processing time and resources
3.  **Relevance**: Older messages may become less relevant to the current conversation
4.  **Coherence**: Maintaining logical flow and preserving important information

Quick setup

For most agents, you can skip manual configuration entirely. See [Context Management](/docs/user-guide/concepts/context-management/index.md).

## Built-in Conversation Managers

The SDK provides a flexible system for context management through the ConversationManager interface. This allows you to implement different strategies for managing conversation history. You can either leverage one of Strands’s provided managers:

-   [**NullConversationManager**](#nullconversationmanager): A simple implementation that does not modify conversation history
-   [**SlidingWindowConversationManager**](#slidingwindowconversationmanager): Maintains a fixed number of recent messages (default manager)
-   [**SummarizingConversationManager**](#summarizingconversationmanager): Intelligently summarizes older messages to preserve context

or [build your own manager](#creating-a-conversationmanager) that matches your requirements.

### NullConversationManager

The [`NullConversationManager`](/docs/api/python/strands.agent.conversation_manager.null_conversation_manager#NullConversationManager) is a simple implementation that does not modify the conversation history. It’s useful for:

-   Short conversations that won’t exceed context limits
-   Debugging purposes
-   Cases where you want to manage context manually

(( tab "Python" ))
```python
from strands import Agent
from strands.agent.conversation_manager import NullConversationManager

agent = Agent(
    conversation_manager=NullConversationManager()
)
```
(( /tab "Python" ))

(( tab "TypeScript" ))
```typescript
import { Agent, NullConversationManager } from '@strands-agents/sdk'

const agent = new Agent({
  conversationManager: new NullConversationManager(),
})
```
(( /tab "TypeScript" ))

### SlidingWindowConversationManager

The [`SlidingWindowConversationManager`](/docs/api/python/strands.agent.conversation_manager.sliding_window_conversation_manager#SlidingWindowConversationManager) implements a sliding window strategy that maintains a fixed number of recent messages. This is the default conversation manager used by the Agent class.

(( tab "Python" ))
```python
from strands import Agent
from strands.agent.conversation_manager import SlidingWindowConversationManager

# Create a conversation manager with custom window size
conversation_manager = SlidingWindowConversationManager(
    window_size=20,  # Maximum number of messages to keep
    should_truncate_results=True, # Enable truncating the tool result when a message is too large for the model's context window
)

agent = Agent(
    conversation_manager=conversation_manager
)
```
(( /tab "Python" ))

(( tab "TypeScript" ))
```typescript
import { Agent, SlidingWindowConversationManager } from '@strands-agents/sdk'

// Create a conversation manager with custom window size
const conversationManager = new SlidingWindowConversationManager({
  windowSize: 40, // Maximum number of messages to keep
  shouldTruncateResults: true, // Enable truncating the tool result when a message is too large for the model's context window
})

const agent = new Agent({
  conversationManager,
})
```
(( /tab "TypeScript" ))

Key features of the `SlidingWindowConversationManager`:

-   **Maintains Window Size**: Automatically removes messages from the window if the number of messages exceeds the limit.
    
-   **Dangling Message Cleanup**: Removes incomplete message sequences to maintain valid conversation state.
    
-   **Overflow Trimming**: In the case of a context window overflow, it will trim the oldest messages from history until the request fits in the models context window.
    
-   **Configurable Tool Result Truncation**: Enable or disable truncation of tool results when the message exceeds context window limits. When enabled (the default; `should_truncate_results=True``shouldTruncateResults: true`), the oldest message with tool results is truncated first so recent context is preserved as long as possible. Truncation depends on content type:
    
    -   Text payloads keep their head and tail, separated by a `<truncated chars="N"/>` marker.
    -   Images, videos, binary documents, and oversized JSON are replaced by a typed placeholder, for example `[image: png, source: bytes, 12345 bytes]`.
    -   The tool result’s original `status` and `error` fields are preserved.
    
    When disabled, full results are preserved but more historical messages may be removed. For a proactive alternative that preserves full content externally, see the [Context Offloader](/docs/user-guide/concepts/plugins/context-offloader/index.md) plugin.
    
-   **Per-Turn Management**: Optionally apply context management proactively during the agent loop execution, not just at the end.
    
-   **Message Pinning**: Protect specific messages from trimming during context reduction. See [Message Pinning](#message-pinning).
    
-   **Proactive Compression**: Pass `proactiveCompression: true` or `proactiveCompression: { compressionThreshold: 0.7 }` to trigger context reduction before the model call when projected input tokens exceed a configurable threshold. See [Proactive Context Compression](#proactive-context-compression).
    

**Per-Turn Management**:

By default, the `SlidingWindowConversationManager` applies context management only after the agent loop completes. The `per_turn` parameter allows you to proactively manage context during execution, which is useful for long-running agent loops with many tool calls.

(( tab "Python" ))
```python
from strands import Agent
from strands.agent.conversation_manager import SlidingWindowConversationManager

# Apply management before every model call
conversation_manager = SlidingWindowConversationManager(
    per_turn=True,  # Apply management before each model call
)

# Or apply management every N model calls
conversation_manager = SlidingWindowConversationManager(
    per_turn=3,  # Apply management every 3 model calls
)

agent = Agent(
    conversation_manager=conversation_manager
)
```
(( /tab "Python" ))

(( tab "TypeScript" ))
```ts
// Not supported in TypeScript
```
(( /tab "TypeScript" ))

The `per_turn` parameter accepts:

-   `False` (default): Only apply management after the agent loop completes
-   `True`: Apply management before every model call
-   An integer `N` (must be > 0): Apply management every N model calls

### SummarizingConversationManager

The [`SummarizingConversationManager`](/docs/api/python/strands.agent.conversation_manager.summarizing_conversation_manager#SummarizingConversationManager) (Python) / [`SummarizingConversationManager`](/docs/api/typescript/SummarizingConversationManager/index.md) (TypeScript) implements intelligent conversation context management by summarizing older messages instead of simply discarding them. This approach preserves important information while staying within context limits.

(( tab "Python" ))
Configuration parameters:

-   **`summary_ratio`** (float, default: 0.3): Ratio of the oldest messages to summarize and replace when reducing context (clamped between 0.1 and 0.8)
-   **`preserve_recent_messages`** (int, default: 10): Minimum number of recent messages to always keep
-   **`summarization_agent`** (Agent, optional): Custom agent for generating summaries. If not provided, uses the main agent instance. Cannot be used together with `summarization_system_prompt`.
-   **`summarization_system_prompt`** (str, optional): Custom system prompt for summarization. If not provided, uses a default prompt that creates structured bullet-point summaries focusing on key topics, tools used, and technical information in third-person format. Cannot be used together with `summarization_agent`.
(( /tab "Python" ))

(( tab "TypeScript" ))
Configuration parameters:

-   **`model`** (Model, optional): Override model to use for generating summaries. When not provided, uses the agent’s own model.
-   **`summaryRatio`** (number, default: 0.3): Ratio of the oldest messages to summarize and replace when reducing context (clamped between 0.1 and 0.8)
-   **`preserveRecentMessages`** (number, default: 10): Minimum number of recent messages to always keep
-   **`summarizationSystemPrompt`** (string, optional): Custom system prompt for summarization. If not provided, uses a default prompt that creates structured bullet-point summaries focusing on key topics, tools used, and technical information in third-person format.
-   **`proactiveCompression`** (`boolean | { compressionThreshold: number }`, optional): Enable proactive context compression before the model call. Pass `true` for the default 0.7 threshold, or an object with a custom threshold. See [Proactive Context Compression](#proactive-context-compression).
(( /tab "TypeScript" ))

**Basic Usage:**

(( tab "Python" ))
By default, the `SummarizingConversationManager` leverages the same model and configuration as your main agent to perform summarization.

```python
from strands import Agent
from strands.agent.conversation_manager import SummarizingConversationManager

agent = Agent(
    conversation_manager=SummarizingConversationManager()
)
```
(( /tab "Python" ))

(( tab "TypeScript" ))
By default, the `SummarizingConversationManager` uses the agent’s own model for summarization. You can optionally provide a different model to override this behavior.

```typescript
import { Agent, SummarizingConversationManager } from '@strands-agents/sdk'

const agent = new Agent({
  conversationManager: new SummarizingConversationManager(),
})
```
(( /tab "TypeScript" ))

You can also customize the behavior by adjusting parameters like summary ratio and number of preserved messages:

(( tab "Python" ))
```python
from strands import Agent
from strands.agent.conversation_manager import SummarizingConversationManager

# Create the summarizing conversation manager with default settings
conversation_manager = SummarizingConversationManager(
    summary_ratio=0.3,  # Summarize and replace the oldest 30% of messages when context reduction is needed
    preserve_recent_messages=10,  # Always keep 10 most recent messages
)

agent = Agent(
    conversation_manager=conversation_manager
)
```
(( /tab "Python" ))

(( tab "TypeScript" ))
```typescript
import { Agent, SummarizingConversationManager, BedrockModel } from '@strands-agents/sdk'

// Optionally use a different model for summarization
const summarizationModel = new BedrockModel({
  modelId: 'global.anthropic.claude-sonnet-4-6',
})

const conversationManager = new SummarizingConversationManager({
  model: summarizationModel, // Override the agent's model for summarization
  summaryRatio: 0.3, // Summarize and replace the oldest 30% of messages
  preserveRecentMessages: 10, // Always keep 10 most recent messages
})

const agent = new Agent({
  conversationManager,
})
```
(( /tab "TypeScript" ))

**Custom System Prompt for Domain-Specific Summarization:**

You can customize the summarization behavior by providing a custom system prompt that tailors the summarization to your domain or use case.

(( tab "Python" ))
```python
from strands import Agent
from strands.agent.conversation_manager import SummarizingConversationManager

# Custom system prompt for technical conversations
custom_system_prompt = """
You are summarizing a technical conversation. Create a concise bullet-point summary that:
- Focuses on code changes, architectural decisions, and technical solutions
- Preserves specific function names, file paths, and configuration details
- Omits conversational elements and focuses on actionable information
- Uses technical terminology appropriate for software development

Format as bullet points without conversational language.
"""

conversation_manager = SummarizingConversationManager(
    summarization_system_prompt=custom_system_prompt
)

agent = Agent(
    conversation_manager=conversation_manager
)
```
(( /tab "Python" ))

(( tab "TypeScript" ))
```typescript
import { Agent, SummarizingConversationManager } from '@strands-agents/sdk'

// Custom system prompt for technical conversations
  const customSystemPrompt = `
You are summarizing a technical conversation.
Create a concise bullet-point summary that:
- Focuses on code changes, architectural decisions, and technical solutions
- Preserves specific function names, file paths, and configuration details
- Omits conversational elements and focuses on actionable information
- Uses technical terminology appropriate for software development

Format as bullet points without conversational language.
`

  const conversationManager = new SummarizingConversationManager({
    summarizationSystemPrompt: customSystemPrompt,
  })

  const agent = new Agent({
    conversationManager,
  })
```
(( /tab "TypeScript" ))

**Advanced Configuration with Custom Summarization Agent:**

(( tab "Python" ))
For advanced use cases, you can provide a custom `summarization_agent` to handle the summarization process. This enables using a different model (such as a faster or a more cost-effective one), incorporating tools during summarization, or implementing specialized summarization logic tailored to your domain. The custom agent can leverage its own system prompt, tools, and model configuration to generate summaries that best preserve the essential context for your specific use case.

```python
from strands import Agent
from strands.agent.conversation_manager import SummarizingConversationManager
from strands.models import AnthropicModel

# Create a cheaper, faster model for summarization tasks
summarization_model = AnthropicModel(
    model_id="claude-haiku-4-5-20251001",  # More cost-effective for summarization
    max_tokens=1000,
    params={"temperature": 0.1}  # Low temperature for consistent summaries
)
custom_summarization_agent = Agent(model=summarization_model)

conversation_manager = SummarizingConversationManager(
    summary_ratio=0.4,
    preserve_recent_messages=8,
    summarization_agent=custom_summarization_agent
)

agent = Agent(
    conversation_manager=conversation_manager
)
```
(( /tab "Python" ))

(( tab "TypeScript" ))
Pass a custom `model` to `SummarizingConversationManager` to override the model used for summarization. This enables using a different model, such as a faster or more cost-effective one, without affecting the agent’s primary model. Injecting a full `Agent` (with its own tools, hooks, or plugins) for summarization is not currently supported in TypeScript.

```typescript
import { Agent, SummarizingConversationManager } from '@strands-agents/sdk'
import { AnthropicModel } from '@strands-agents/sdk/models/anthropic'

// Use a cheaper, faster model for summarization tasks
const summarizationModel = new AnthropicModel({
  modelId: 'claude-haiku-4-5-20251001',
  maxTokens: 1000,
  params: { temperature: 0.1 }, // Low temperature for consistent summaries
})

const conversationManager = new SummarizingConversationManager({
  model: summarizationModel,
  summaryRatio: 0.4,
  preserveRecentMessages: 8,
})

const agent = new Agent({
  conversationManager,
})
```
(( /tab "TypeScript" ))

#### Key Features

-   **Context Window Management**: Automatically reduces context when token limits are exceeded
-   **Intelligent Summarization**: Uses structured bullet-point summaries to capture key information
-   **Tool Pair Preservation**: Ensures tool use and result message pairs aren’t broken during summarization
-   **Message Pinning**: Protect specific messages from summarization during context reduction. See [Message Pinning](#message-pinning).
-   **Flexible Configuration**: Customize summarization behavior through various parameters
-   **Fallback Safety**: Handles summarization failures gracefully

## Message Pinning

Message pinning protects specific messages from eviction during context reduction. Pinned messages survive both sliding-window trimming and summarization, which makes pinning useful for preserving system prompts, critical instructions, or key decisions that must remain in the conversation regardless of length.

Messages are pinned by setting `metadata.custom.pinned = true` on the message object. The SDK provides both a declarative configuration (`pin_first` / `pinFirst`) and runtime utility functions for programmatic control.

### Protecting Initial Messages with `pin_first`

Both `SlidingWindowConversationManager` and `SummarizingConversationManager` accept a `pin_first` (Python) / `pinFirst` (TypeScript) parameter that permanently protects the first N messages from eviction. This is the simplest way to preserve system prompts or initial instructions across all context reductions.

(( tab "Python" ))
```python
from strands import Agent
from strands.agent.conversation_manager import SlidingWindowConversationManager

agent = Agent(
    conversation_manager=SlidingWindowConversationManager(
        window_size=40,
        pin_first=1,
    )
)
```

The same parameter works with `SummarizingConversationManager`:

```python
from strands.agent.conversation_manager import SummarizingConversationManager

agent = Agent(
    conversation_manager=SummarizingConversationManager(
        pin_first=2,
    )
)
```
(( /tab "Python" ))

(( tab "TypeScript" ))
```typescript
import { Agent, SlidingWindowConversationManager } from '@strands-agents/sdk'

const agent = new Agent({
  conversationManager: new SlidingWindowConversationManager({
    windowSize: 40,
    pinFirst: 1,
  }),
})
```

The same parameter works with `SummarizingConversationManager`.
(( /tab "TypeScript" ))

The pin metadata is written during the first context reduction and remains set permanently, protecting those messages through all subsequent reductions.

## Proactive Context Compression

By default, conversation managers are reactive. They only reduce context after the model rejects a request with a context window overflow error. Proactive compression avoids wasting round-trips and output token starvation by triggering context reduction before the model call when the projected input token count exceeds a configurable threshold of the model’s context window.

### Enabling Proactive Compression

(( tab "Python" ))
Pass `proactive_compression` to any built-in conversation manager. Use `True` for the default 0.7 threshold, or pass a dict with a custom `compression_threshold` ratio between 0 and 1. For example, `0.7` will trigger compression when 70% of the model’s context window is used:

**With SlidingWindowConversationManager:**

```python
from strands import Agent
from strands.agent.conversation_manager import SlidingWindowConversationManager

agent = Agent(
    conversation_manager=SlidingWindowConversationManager(
        window_size=50,
        proactive_compression={"compression_threshold": 0.7},
    ),
)
```

**With SummarizingConversationManager:**

```python
from strands import Agent
from strands.agent.conversation_manager import SummarizingConversationManager

agent = Agent(
    conversation_manager=SummarizingConversationManager(
        proactive_compression=True,
    ),
)
```

Without `proactive_compression`, only reactive overflow recovery is used.
(( /tab "Python" ))

(( tab "TypeScript" ))
Pass `proactiveCompression` to any built-in conversation manager. Use `true` for the default 0.7 threshold, or pass an object with a custom `compressionThreshold` ratio between 0 and 1. For example, `0.7` will trigger compression when 70% of the model’s context window is used:

**With SlidingWindowConversationManager:**

```typescript
import { Agent, SlidingWindowConversationManager } from '@strands-agents/sdk'

const agent = new Agent({
  conversationManager: new SlidingWindowConversationManager({
    windowSize: 50,
    proactiveCompression: { compressionThreshold: 0.7 },
  }),
})
```

**With SummarizingConversationManager:**

```typescript
import { Agent, SummarizingConversationManager } from '@strands-agents/sdk'

const agent = new Agent({
  conversationManager: new SummarizingConversationManager({
    proactiveCompression: true,
  }),
})
```

Without `proactiveCompression`, only reactive overflow recovery is used.
(( /tab "TypeScript" ))

### How It Works

Before each model call, the agent estimates the projected input token count and attaches it to the `BeforeModelCallEvent`. When proactive compression is configured, the conversation manager compares this estimate against the model’s `contextWindowLimit`:

```plaintext
if projectedInputTokens / contextWindowLimit >= compressionThreshold:
    reduce()  // proactively compress context
```

Each conversation manager uses the same reduction logic for proactive compression as reactive overflow recovery. Proactive compression is best-effort only, so if `reduce()` throws or returns `false`, the error is swallowed and the model call proceeds normally.

Because `BeforeModelCallEvent` triggers before every model call including calls within a tool-use cycle, this provides automatic in-loop compression. If an agent makes five tool calls in a single invocation and context grows past the threshold between calls three and four, compression triggers before call four.

### Context Window Limit

The threshold check requires the model’s context window size. The SDK auto-populates `contextWindowLimit` from built-in lookup tables ([Python](https://github.com/strands-agents/harness-sdk/blob/main/strands-py/src/strands/models/_defaults.py), [TypeScript](https://github.com/strands-agents/harness-sdk/blob/main/strands-ts/src/models/defaults.ts)) for known models. You can override it manually for models not in the lookup table:

(( tab "Python" ))
```python
model = BedrockModel(
    model_id="my-custom-model",
    context_window_limit=128_000,
)
```
(( /tab "Python" ))

(( tab "TypeScript" ))
```typescript
const model = new BedrockModel({
  modelId: 'my-custom-model',
  contextWindowLimit: 128_000,
})
```
(( /tab "TypeScript" ))

Inaccurate compression with default fallback

If `contextWindowLimit` is not set and the model ID is not in the built-in lookup table, the SDK falls back to a default of 200,000 tokens. When the default token limit is used but the model’s actual context window is significantly different, proactive compression will not behave correctly.

### Token Estimation

The agent estimates input tokens using the following strategy:

1.  **Known baseline**: Reads `inputTokens + outputTokens` from the last assistant message’s `metadata.usage`
2.  **Delta estimation**: Only estimates tokens for new messages added since that assistant message using the model’s `countTokens()` method
3.  **Cold start fallback**: When no prior usage metadata exists (first call or after session restore without metadata), estimates all messages via `countTokens()`

The `countTokens()` method uses a character-based heuristic to estimate token count by default (characters ÷ 4 for text, characters ÷ 2 for JSON). Some model providers support native token counting APIs for exact counts, which can be enabled on the model. See the Token Counting section on each provider’s page for details and instructions:

-   [Amazon Bedrock](/docs/user-guide/concepts/model-providers/amazon-bedrock/index.md#token-counting)
-   [Anthropic](/docs/user-guide/concepts/model-providers/anthropic/index.md#token-counting)
-   [Google Gemini](/docs/user-guide/concepts/model-providers/google/index.md#token-counting)
-   [OpenAI Responses](/docs/user-guide/concepts/model-providers/openai-responses/index.md#token-counting)
-   [llama.cpp](/docs/user-guide/concepts/model-providers/llamacpp/index.md#token-counting)

## Creating a ConversationManager

(( tab "Python" ))
To create a custom conversation manager, implement the [`ConversationManager`](/docs/api/python/strands.agent.conversation_manager.conversation_manager#ConversationManager) interface, which is composed of three key elements:

1.  [`apply_management`](/docs/api/python/strands.agent.conversation_manager.conversation_manager#ConversationManager.apply_management): This method is called after each event loop cycle completes to manage the conversation history. It’s responsible for applying your management strategy to the messages array, which may have been modified with tool results and assistant responses. The agent runs this method automatically after processing each user input and generating a response.
    
2.  [`reduce_context`](/docs/api/python/strands.agent.conversation_manager.conversation_manager#ConversationManager.reduce_context): This method is called when the model’s context window is exceeded (typically due to token limits). It implements the specific strategy for reducing the window size when necessary. The agent calls this method when it encounters a context window overflow exception, giving your implementation a chance to trim the conversation history before retrying.
    
3.  `removed_message_count`: This attribute is tracked by conversation managers, and utilized by [Session Management](/docs/user-guide/concepts/agents/session-management/index.md) to efficiently load messages from the session storage. The count represents messages provided by the user or LLM that have been removed from the agent’s messages, but not messages included by the conversation manager through something like summarization.
    
4.  `register_hooks` (optional): Override this method to integrate with [hooks](/docs/user-guide/concepts/agents/hooks/index.md). This enables proactive context management patterns, such as trimming context before model calls. Always call `super().register_hooks` when overriding.
    

See the [SlidingWindowConversationManager](https://github.com/strands-agents/harness-sdk/blob/main/strands-py/src/strands/agent/conversation_manager/sliding_window_conversation_manager.py) implementation as a reference example.
(( /tab "Python" ))

(( tab "TypeScript" ))
To create a custom conversation manager, extend the abstract [`ConversationManager`](/docs/api/typescript/ConversationManager/index.md) base class and implement the `reduce` method:

1.  **`reduce(options: ReduceOptions): boolean`**: Called in two scenarios: reactively when a `ContextWindowOverflowError` occurs (`options.error` is set), and proactively before model calls that exceed the compression threshold (`options.error` is `undefined`). Mutate `agent.messages` in place to reduce history, then return `true` if any reduction was made. When `error` is set, returning `false` lets the error propagate out of the agent loop uncaught. When `error` is `undefined`, returning `false` or throwing is safe — the model call proceeds regardless.
    
2.  **`initAgent(agent)` (optional)**: Override to add proactive management (e.g. trimming after each invocation). Always call `super.initAgent(agent)` to preserve the built-in overflow recovery and proactive compression hooks.
    

```typescript
import {
  Agent,
  ConversationManager,
  type ConversationManagerReduceOptions,
} from '@strands-agents/sdk'

class Last10MessagesManager extends ConversationManager {
  readonly name = 'my:last-10-messages'

  reduce({ agent }: ConversationManagerReduceOptions): boolean {
    if (agent.messages.length <= 10) return false
    agent.messages.splice(0, agent.messages.length - 10)
    return true
  }
}

const agent = new Agent({
  conversationManager: new Last10MessagesManager(),
})
```

For proactive management alongside overflow recovery, override `initAgent`:

```typescript
import {
  Agent,
  ConversationManager,
  AfterInvocationEvent,
  type AgentData,
  type ConversationManagerReduceOptions,
} from '@strands-agents/sdk'

class MyManager extends ConversationManager {
  readonly name = 'my:manager'
  private readonly _maxMessages = 5

  reduce({ agent }: ConversationManagerReduceOptions): boolean {
    return this._trim(agent.messages)
  }

  override initAgent(agent: LocalAgent): void {
    super.initAgent(agent) // preserves overflow recovery
    agent.addHook(AfterInvocationEvent, (event) => {
      this._trim(event.agent.messages)
    })
  }

  private _trim(messages: LocalAgent['messages']): boolean {
    if (messages.length <= this._maxMessages) return false
    messages.splice(0, messages.length - this._maxMessages)
    return true
  }
}
```

See the [SlidingWindowConversationManager](https://github.com/strands-agents/harness-sdk/blob/main/strands-ts/src/conversation-manager/sliding-window-conversation-manager.ts) implementation as a reference example.
(( /tab "TypeScript" ))

## Related pages

- [Context Management](/docs/user-guide/concepts/context-management/index.md) (2 shared tags)
- [Context Offloader](/docs/user-guide/concepts/plugins/context-offloader/index.md) (2 shared tags)
- [Context Injector](/docs/user-guide/concepts/plugins/context-injector/index.md) (1 shared tag)
- [Storage](/docs/user-guide/concepts/storage/index.md) (1 shared tag)
- [Coherence Evaluator](/docs/user-guide/evals-sdk/evaluators/coherence_evaluator/index.md) (1 shared tag)
- [Conciseness Evaluator](/docs/user-guide/evals-sdk/evaluators/conciseness_evaluator/index.md) (1 shared tag)
- [Goal Success Rate Evaluator](/docs/user-guide/evals-sdk/evaluators/goal_success_rate_evaluator/index.md) (1 shared tag)
- [Helpfulness Evaluator](/docs/user-guide/evals-sdk/evaluators/helpfulness_evaluator/index.md) (1 shared tag)
- [Interactions Evaluator](/docs/user-guide/evals-sdk/evaluators/interactions_evaluator/index.md) (1 shared tag)
- [Output Evaluator](/docs/user-guide/evals-sdk/evaluators/output_evaluator/index.md) (1 shared tag)


## Implementation

### Python

- [harness-sdk/strands-py/src/strands/agent/conversation_manager/conversation_manager.py](https://github.com/strands-agents/harness-sdk/blob/main/strands-py/src/strands/agent/conversation_manager/conversation_manager.py)
- [harness-sdk/strands-py/src/strands/agent/conversation_manager/sliding_window_conversation_manager.py](https://github.com/strands-agents/harness-sdk/blob/main/strands-py/src/strands/agent/conversation_manager/sliding_window_conversation_manager.py)
- [harness-sdk/strands-py/src/strands/agent/conversation_manager/summarizing_conversation_manager.py](https://github.com/strands-agents/harness-sdk/blob/main/strands-py/src/strands/agent/conversation_manager/summarizing_conversation_manager.py)

### TypeScript

- [harness-sdk/strands-ts/src/conversation-manager/conversation-manager.ts](https://github.com/strands-agents/harness-sdk/blob/main/strands-ts/src/conversation-manager/conversation-manager.ts)
- [harness-sdk/strands-ts/src/conversation-manager/sliding-window-conversation-manager.ts](https://github.com/strands-agents/harness-sdk/blob/main/strands-ts/src/conversation-manager/sliding-window-conversation-manager.ts)
- [harness-sdk/strands-ts/src/conversation-manager/summarizing-conversation-manager.ts](https://github.com/strands-agents/harness-sdk/blob/main/strands-ts/src/conversation-manager/summarizing-conversation-manager.ts)