What can Session Control do?

mcp-based session lifecycle management, runtime limit enforcement and quota management, health check and status monitoring, security guardrails and sandboxing configuration, configurable logging and audit trail generation, dynamic configuration updates without session restart, multi-session isolation and resource sharing policies, error recovery and retry policy configuration

Session Control

AgentFree

Manage session settings, health checks, and security safeguards in one place. Configure limits, logging, and sandboxing to fit your workflows. Monitor status and adjust behavior without leaving your workspace.

Open Source

/ 100

8 capabilities

Capabilities8 decomposed

mcp-based session lifecycle management

Medium confidence

Manages session initialization, configuration, and teardown through the Model Context Protocol (MCP) server interface. Implements session state tracking with lifecycle hooks that allow agents to initialize resources, configure runtime parameters, and gracefully shut down. Uses MCP's resource and tool abstractions to expose session operations as standardized endpoints that any MCP-compatible client can invoke.

Solves for

Initialize a new agent session with custom configuration parametersRetrieve current session state and active configurationTerminate a session and clean up associated resourcesTrack session metadata including creation time, last activity, and resource usage

Best for

Teams building MCP-compatible agents and needing centralized session control

Developers integrating multiple LLM clients that need unified session management

Organizations requiring audit trails and session lifecycle tracking

Requires

MCP client implementation (e.g., Claude Desktop, custom MCP client library)

Node.js 16+ or Python 3.8+ (depending on MCP server runtime)

Network connectivity to MCP server endpoint

Limitations

Session state is ephemeral unless backed by external persistence layer — no built-in database integration

No distributed session support across multiple MCP server instances without external coordination

Session timeout and expiration policies must be implemented by consuming client

What makes it unique

Exposes session control as MCP resources and tools rather than REST endpoints, enabling seamless integration with MCP-native clients like Claude Desktop without requiring custom API wrappers or authentication layers

vs alternatives

Simpler than building custom session APIs because it leverages MCP's standardized resource/tool model, reducing boilerplate and enabling immediate compatibility with any MCP client

runtime limit enforcement and quota management

Medium confidence

Enforces configurable limits on agent execution including token budgets, execution time, API call counts, and memory usage. Implements quota tracking at the session level with real-time monitoring and hard cutoffs when limits are exceeded. Uses counter-based tracking and timeout mechanisms to prevent runaway executions and resource exhaustion.

Solves for

Set per-session token budgets to control LLM API costsDefine maximum execution duration to prevent infinite loops or hanging agentsLimit number of tool calls or API invocations per sessionMonitor current resource consumption and remaining quota in real-time

Best for

Teams running untrusted or experimental agent code in shared environments

Cost-conscious organizations needing granular control over LLM API spending

Developers building multi-tenant agent platforms with per-user resource quotas

Requires

MCP server runtime with timer/counter support

Client implementation that respects quota exceeded responses

Configuration schema defining limit types and thresholds

Limitations

Quota enforcement is synchronous and blocking — no graceful degradation or backpressure mechanisms

Token counting relies on client-provided estimates; actual token usage may vary by model

No support for quota pooling or burst allowances — limits are strictly enforced per session

What makes it unique

Implements quota enforcement at the MCP protocol layer rather than in application code, allowing limits to be enforced consistently across all clients and tools without requiring per-tool instrumentation

vs alternatives

More reliable than application-level quota checks because it operates at the session boundary where all requests pass through, preventing quota bypass via direct tool invocation

health check and status monitoring

Medium confidence

Provides real-time health status of the agent session and underlying MCP server infrastructure. Implements periodic health checks that verify connectivity, resource availability, and dependency health (e.g., API endpoints, database connections). Exposes health status via MCP resources that clients can poll or subscribe to, with configurable check intervals and failure thresholds.

Solves for

Check if an agent session is healthy and ready to accept requestsMonitor MCP server uptime and detect degradation or failuresVerify that external dependencies (APIs, databases) are accessibleGet detailed health diagnostics including latency, error rates, and resource utilization

Best for

Production deployments requiring uptime monitoring and alerting

Teams managing multiple MCP servers and needing centralized health visibility

Developers building resilient agent systems with failover or retry logic

Requires

MCP server with health check endpoint implementation

Client capable of polling health status periodically

Configuration defining which dependencies to check and timeout thresholds

Limitations

Health checks are point-in-time snapshots; transient failures may not be captured

No built-in alerting or notification system — clients must implement their own monitoring

Health check latency adds overhead; frequent checks may impact performance

What makes it unique

Integrates health checks into the MCP resource model, allowing clients to query health status using the same protocol as other session operations, eliminating the need for separate monitoring infrastructure

vs alternatives

More lightweight than external monitoring systems because health checks are co-located with the session and don't require separate agents or infrastructure

security guardrails and sandboxing configuration

Medium confidence

Configures security policies and sandboxing constraints for agent execution including allowed tool/function whitelists, input validation rules, and output filtering policies. Implements policy enforcement at the MCP layer by intercepting tool calls and validating them against configured rules before execution. Supports multiple policy types including allowlist-based tool access, input schema validation, and output content filtering.

Solves for

Restrict which tools or functions an agent can invoke based on a whitelistDefine input validation rules to prevent injection attacks or malformed requestsFilter or redact sensitive information from agent outputsEnforce role-based access control for different agent sessions

Best for

Teams deploying agents in multi-tenant or untrusted environments

Organizations with compliance requirements (PCI-DSS, HIPAA) needing data protection

Developers building agent platforms with fine-grained permission models

Requires

MCP server with policy enforcement middleware

Policy configuration file or API defining allowed tools, input schemas, output filters

Client that respects policy violation responses

Limitations

Policy enforcement is synchronous and adds latency (~10-50ms per tool call depending on rule complexity)

No support for dynamic policy updates without restarting the session

Output filtering is regex/pattern-based and may miss sophisticated data exfiltration attempts

What makes it unique

Implements security policies as declarative MCP middleware rather than scattered throughout agent code, enabling consistent enforcement across all tools and making policies auditable and version-controllable

vs alternatives

More maintainable than per-tool security checks because policies are centralized and can be updated without modifying agent or tool code

configurable logging and audit trail generation

Medium confidence

Captures detailed logs of all session activity including tool invocations, parameter values, results, errors, and timing information. Implements structured logging with configurable verbosity levels and output destinations (stdout, files, external services). Generates audit trails suitable for compliance and debugging, with optional redaction of sensitive fields based on configured patterns.

Solves for

Debug agent behavior by reviewing detailed execution logsGenerate audit trails for compliance and security investigationsMonitor agent performance by analyzing timing and error patternsExport session logs to external systems for centralized logging and analysis

Best for

Teams operating agents in regulated industries requiring audit trails

Developers debugging complex agent behaviors and multi-step workflows

Organizations centralizing logs across multiple MCP servers and agents

Requires

MCP server with logging infrastructure

Log output destination (file, stdout, or external service endpoint)

Configuration defining log level, fields to capture, and redaction patterns

Limitations

Verbose logging adds overhead (~5-20% depending on log level) and increases memory usage

Sensitive data redaction is pattern-based and may miss context-specific sensitive information

No built-in log rotation or retention policies — must be managed externally

What makes it unique

Integrates logging at the MCP session boundary, capturing all activity uniformly without requiring instrumentation of individual tools or agent code, and supports redaction policies to protect sensitive data

vs alternatives

More comprehensive than application-level logging because it captures all MCP protocol traffic including tool calls and responses, providing a complete audit trail

dynamic configuration updates without session restart

Medium confidence

Allows modification of session settings (limits, logging levels, security policies, health check intervals) at runtime via MCP tool calls without requiring session termination and restart. Implements configuration change handlers that validate new settings and apply them atomically to the running session. Supports rollback of invalid configurations and maintains configuration history for audit purposes.

Solves for

Increase token budget for a long-running agent task without restartingEnable verbose logging to debug an issue in a live sessionUpdate security policies to allow new tools mid-sessionAdjust health check frequency based on observed stability

Best for

Production environments where session restarts are costly or disruptive

Interactive debugging scenarios where developers need to adjust settings on-the-fly

Long-running agents that need configuration adjustments without interruption

Requires

MCP server with configuration update endpoint

Configuration schema defining valid settings and constraints

Client capability to invoke configuration update tools

Limitations

Configuration changes are not persisted across server restarts unless explicitly saved

No transactional guarantees — partial configuration updates may leave session in inconsistent state

Rollback is manual; no automatic rollback on configuration validation failures

What makes it unique

Exposes configuration updates as MCP tools rather than requiring direct server API access, allowing configuration changes to be triggered by agents themselves or by clients without elevated privileges

vs alternatives

More flexible than static configuration files because settings can be adjusted in response to runtime conditions without service restarts

multi-session isolation and resource sharing policies

Medium confidence

Manages isolation boundaries between concurrent sessions running on the same MCP server, preventing resource contention and cross-session interference. Implements per-session resource quotas, namespace isolation for state/memory, and optional resource sharing policies (e.g., shared connection pools). Tracks resource usage per session and enforces isolation constraints at the MCP layer.

Solves for

Run multiple independent agent sessions on a single MCP server without interferencePrevent one session's resource exhaustion from affecting other sessionsShare expensive resources (e.g., database connections) across sessions while maintaining isolationMonitor per-session resource consumption and enforce fair-share policies

Best for

Multi-tenant agent platforms serving multiple users/organizations

Cost-optimized deployments consolidating multiple agents on shared infrastructure

Teams needing strong isolation guarantees for security or compliance

Requires

MCP server with session isolation support

Configuration defining isolation policies and resource sharing rules

Monitoring/telemetry to track per-session resource usage

Limitations

Isolation is logical (namespace-based) not OS-level; no memory or CPU isolation without containerization

Shared resource pools (e.g., connection pools) create coupling between sessions and potential bottlenecks

No automatic load balancing or session migration across servers

What makes it unique

Implements session isolation at the MCP protocol layer using namespace-based separation and per-session quota enforcement, enabling multi-tenant deployments without requiring separate server instances

vs alternatives

More efficient than running separate MCP server instances because it consolidates multiple sessions on shared infrastructure while maintaining isolation through logical boundaries

error recovery and retry policy configuration

Medium confidence

Configures automatic retry behavior for transient failures including exponential backoff, jitter, max retry counts, and per-error-type retry policies. Implements circuit breaker patterns to prevent cascading failures when external dependencies are unavailable. Tracks retry attempts and failure patterns to inform debugging and operational decisions.

Solves for

Automatically retry failed tool calls with exponential backoffConfigure different retry strategies for different error types (network vs. validation)Prevent cascading failures by opening circuit breakers when error rates exceed thresholdsMonitor retry patterns to identify systemic issues

Best for

Agents calling external APIs or services prone to transient failures

Production deployments requiring resilience to temporary outages

Teams building fault-tolerant agent systems with minimal manual intervention

Requires

MCP server with retry/circuit breaker middleware

Configuration defining retry policies (max_attempts, backoff_strategy, error_type_rules)

Client that respects retry responses and doesn't timeout during retries

Limitations

Retry logic adds latency; worst-case retry duration can be minutes with aggressive backoff

Circuit breakers are per-session; no coordination across sessions for shared dependencies

Idempotency is assumed but not enforced; retrying non-idempotent operations may cause side effects

What makes it unique

Implements retry and circuit breaker logic at the MCP session layer, applying consistently to all tool calls without requiring per-tool instrumentation, and supports error-type-specific retry strategies

vs alternatives

More reliable than per-tool retry logic because it operates at the session boundary where all requests pass through, ensuring consistent retry behavior across all tools

Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.

Related Artifactssharing capabilities

Artifacts that share capabilities with Session Control, ranked by overlap. Discovered automatically through the match graph.

MCP Server27

SAP ABAP MCP Server SDK

** - Build SAP ABAP based MCP servers. ABAP 7.52 based with 7.02 downport; runs on R/3 & S/4HANA on-premises, currently not cloud-ready.

session cleanup and lifecycle management for long-running mcp serversstateful and stateless session management for mcp interactions

2 shared capabilities

CLI Tool27

mcp-client

** MCP REST API and CLI client for interacting with MCP servers, supports OpenAI, Claude, Gemini, Ollama etc.

rate limiting and quota enforcement for mcp tool callsconnection pooling and session management for mcp servers

2 shared capabilities

MCP Server34

@browserstack/mcp-server

BrowserStack's Official MCP Server

session state management and cleanup

1 shared capability

MCP Server23

AWS Core

** - Core AWS MCP server providing prompt understanding and server management capabilities.

resource quota and rate limiting enforcement

1 shared capability

MCP Server33

metamcp

MCP Aggregator, Orchestrator, Middleware, Gateway in one docker

session pool management with cold-start optimization

1 shared capability

MCP Server25

@metorial/mcp-session

MCP session management for Metorial. Provides session handling and tool lifecycle management for Model Context Protocol.

mcp session lifecycle management with stateful context preservation

1 shared capability

Best For

✓Teams building MCP-compatible agents and needing centralized session control
✓Developers integrating multiple LLM clients that need unified session management
✓Organizations requiring audit trails and session lifecycle tracking
✓Teams running untrusted or experimental agent code in shared environments
✓Cost-conscious organizations needing granular control over LLM API spending
✓Developers building multi-tenant agent platforms with per-user resource quotas
✓Production deployments requiring uptime monitoring and alerting
✓Teams managing multiple MCP servers and needing centralized health visibility

Known Limitations

⚠Session state is ephemeral unless backed by external persistence layer — no built-in database integration
⚠No distributed session support across multiple MCP server instances without external coordination
⚠Session timeout and expiration policies must be implemented by consuming client
⚠Quota enforcement is synchronous and blocking — no graceful degradation or backpressure mechanisms
⚠Token counting relies on client-provided estimates; actual token usage may vary by model
⚠No support for quota pooling or burst allowances — limits are strictly enforced per session

Requirements

MCP client implementation (e.g., Claude Desktop, custom MCP client library)Node.js 16+ or Python 3.8+ (depending on MCP server runtime)Network connectivity to MCP server endpointMCP server runtime with timer/counter supportClient implementation that respects quota exceeded responsesConfiguration schema defining limit types and thresholdsMCP server with health check endpoint implementationClient capable of polling health status periodically

Input / Output

Accepts: JSON configuration objects, session identifiers (UUID or string), parameter key-value pairs, limit configuration objects (token_budget, max_duration_ms, max_calls), resource consumption metrics (tokens_used, duration_elapsed, calls_made), health check configuration (check_interval_ms, timeout_ms, dependency_list), optional custom health check logic, policy configuration objects (tool_whitelist, input_schemas, output_filters), tool call requests with parameters, agent output for filtering, logging configuration (level, format, output_destination, redaction_rules), session events (tool_calls, results, errors, state_changes), configuration update objects (setting_name, new_value), optional validation rules or constraints, session creation requests with isolation and sharing preferences, resource quota specifications per session, resource sharing policy definitions, retry policy configuration (max_attempts, initial_delay_ms, backoff_multiplier, jitter), circuit breaker configuration (failure_threshold, timeout_ms, half_open_requests), error classification rules (which errors are retryable)

Produces: JSON session state objects, structured session metadata, confirmation/status messages, quota status objects with remaining/used amounts, quota exceeded error responses with detail, consumption telemetry for monitoring, health status objects (status: 'healthy'|'degraded'|'unhealthy', details, timestamp), dependency health details (name, status, latency_ms, last_checked), error messages and diagnostic information, policy enforcement results (allowed/denied with reason), validated/filtered tool calls and outputs, policy violation error responses, structured log entries (JSON or custom format), audit trail records with timestamps and actor information, aggregated logs and statistics, configuration update confirmation with applied settings, validation error messages if update is rejected, configuration history or diff showing what changed, session identifiers with isolation guarantees, per-session resource usage metrics, resource contention warnings or errors, retry attempt details (attempt_number, delay_ms, next_retry_time), circuit breaker status (open/closed/half-open), final success/failure after all retries exhausted

UnfragileRank

Adoption5%(25% weight)

Quality31%(25% weight)

Ecosystem59%(10% weight)

Match Graph25%(35% weight)

Freshness75%(5% weight)

UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.

Type: Agent

8 capabilities

Visit Session Control→

Repository Details

About

Alternatives to Session Control

Supabase69Platform

Search the Supabase docs for up-to-date guidance and troubleshoot errors quickly. Manage organizations, projects, databases, and Edge Functions, including migrations, SQL, logs, advisors, keys, and type generation, in one flow. Create and manage development branches to iterate safely, confirm costs

Compare →

Tavily MCP Server62MCP Server

AI-optimized web search and content extraction via Tavily MCP.

Compare →

MongoDB MCP Server62MCP Server

Query and manage MongoDB databases and collections via MCP.

Compare →

Firecrawl MCP Server62MCP Server

Scrape websites and extract structured data via Firecrawl MCP.

Compare →

Are you the builder of Session Control?

Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.

Claim this artifact →Verification via email

Get the weekly brief

New tools, rising stars, and what's actually worth your time. No spam.

Data Sources

smithery

Looking for something else?

Search →

Capabilities8 decomposed

mcp-based session lifecycle management

Medium confidence

Solves for

Best for

Teams building MCP-compatible agents and needing centralized session control

Developers integrating multiple LLM clients that need unified session management

Organizations requiring audit trails and session lifecycle tracking

Requires

MCP client implementation (e.g., Claude Desktop, custom MCP client library)

Node.js 16+ or Python 3.8+ (depending on MCP server runtime)

Network connectivity to MCP server endpoint

Limitations

Session state is ephemeral unless backed by external persistence layer — no built-in database integration

No distributed session support across multiple MCP server instances without external coordination

Session timeout and expiration policies must be implemented by consuming client

What makes it unique

vs alternatives

Simpler than building custom session APIs because it leverages MCP's standardized resource/tool model, reducing boilerplate and enabling immediate compatibility with any MCP client

runtime limit enforcement and quota management

Medium confidence

Solves for

Best for

Teams running untrusted or experimental agent code in shared environments

Cost-conscious organizations needing granular control over LLM API spending

Developers building multi-tenant agent platforms with per-user resource quotas

Requires

MCP server runtime with timer/counter support

Client implementation that respects quota exceeded responses

Configuration schema defining limit types and thresholds

Limitations

Quota enforcement is synchronous and blocking — no graceful degradation or backpressure mechanisms

Token counting relies on client-provided estimates; actual token usage may vary by model

No support for quota pooling or burst allowances — limits are strictly enforced per session

What makes it unique

vs alternatives

More reliable than application-level quota checks because it operates at the session boundary where all requests pass through, preventing quota bypass via direct tool invocation

health check and status monitoring

Medium confidence

Solves for

Best for

Production deployments requiring uptime monitoring and alerting

Teams managing multiple MCP servers and needing centralized health visibility

Developers building resilient agent systems with failover or retry logic

Requires

MCP server with health check endpoint implementation

Client capable of polling health status periodically

Configuration defining which dependencies to check and timeout thresholds

Limitations

Health checks are point-in-time snapshots; transient failures may not be captured

No built-in alerting or notification system — clients must implement their own monitoring

Health check latency adds overhead; frequent checks may impact performance

What makes it unique

vs alternatives

More lightweight than external monitoring systems because health checks are co-located with the session and don't require separate agents or infrastructure

security guardrails and sandboxing configuration

Medium confidence

Solves for

Best for

Teams deploying agents in multi-tenant or untrusted environments

Organizations with compliance requirements (PCI-DSS, HIPAA) needing data protection

Developers building agent platforms with fine-grained permission models

Requires

MCP server with policy enforcement middleware

Policy configuration file or API defining allowed tools, input schemas, output filters

Client that respects policy violation responses

Limitations

Policy enforcement is synchronous and adds latency (~10-50ms per tool call depending on rule complexity)

No support for dynamic policy updates without restarting the session

Output filtering is regex/pattern-based and may miss sophisticated data exfiltration attempts

What makes it unique

vs alternatives

More maintainable than per-tool security checks because policies are centralized and can be updated without modifying agent or tool code

configurable logging and audit trail generation

Medium confidence

Solves for

Best for

Teams operating agents in regulated industries requiring audit trails

Developers debugging complex agent behaviors and multi-step workflows

Organizations centralizing logs across multiple MCP servers and agents

Requires

MCP server with logging infrastructure

Log output destination (file, stdout, or external service endpoint)

Configuration defining log level, fields to capture, and redaction patterns

Limitations

Verbose logging adds overhead (~5-20% depending on log level) and increases memory usage

Sensitive data redaction is pattern-based and may miss context-specific sensitive information

No built-in log rotation or retention policies — must be managed externally

What makes it unique

vs alternatives

More comprehensive than application-level logging because it captures all MCP protocol traffic including tool calls and responses, providing a complete audit trail

dynamic configuration updates without session restart

Medium confidence

Solves for

Best for

Production environments where session restarts are costly or disruptive

Interactive debugging scenarios where developers need to adjust settings on-the-fly

Long-running agents that need configuration adjustments without interruption

Requires

MCP server with configuration update endpoint

Configuration schema defining valid settings and constraints

Client capability to invoke configuration update tools

Limitations

Configuration changes are not persisted across server restarts unless explicitly saved

No transactional guarantees — partial configuration updates may leave session in inconsistent state

Rollback is manual; no automatic rollback on configuration validation failures

What makes it unique

vs alternatives

More flexible than static configuration files because settings can be adjusted in response to runtime conditions without service restarts

multi-session isolation and resource sharing policies

Medium confidence

Solves for

Best for

Multi-tenant agent platforms serving multiple users/organizations

Cost-optimized deployments consolidating multiple agents on shared infrastructure

Teams needing strong isolation guarantees for security or compliance

Requires

MCP server with session isolation support

Configuration defining isolation policies and resource sharing rules

Monitoring/telemetry to track per-session resource usage

Limitations

Isolation is logical (namespace-based) not OS-level; no memory or CPU isolation without containerization

Shared resource pools (e.g., connection pools) create coupling between sessions and potential bottlenecks

No automatic load balancing or session migration across servers

What makes it unique

vs alternatives

More efficient than running separate MCP server instances because it consolidates multiple sessions on shared infrastructure while maintaining isolation through logical boundaries

error recovery and retry policy configuration

Medium confidence

Solves for

Best for

Agents calling external APIs or services prone to transient failures

Production deployments requiring resilience to temporary outages

Teams building fault-tolerant agent systems with minimal manual intervention

Requires

MCP server with retry/circuit breaker middleware

Configuration defining retry policies (max_attempts, backoff_strategy, error_type_rules)

Client that respects retry responses and doesn't timeout during retries

Limitations

Retry logic adds latency; worst-case retry duration can be minutes with aggressive backoff

Circuit breakers are per-session; no coordination across sessions for shared dependencies

Idempotency is assumed but not enforced; retrying non-idempotent operations may cause side effects

What makes it unique

vs alternatives

More reliable than per-tool retry logic because it operates at the session boundary where all requests pass through, ensuring consistent retry behavior across all tools

Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.

Alternatives to Session Control

Supabase69Platform

Compare →

Tavily MCP Server62MCP Server

AI-optimized web search and content extraction via Tavily MCP.

Compare →

MongoDB MCP Server62MCP Server

Query and manage MongoDB databases and collections via MCP.

Compare →

Firecrawl MCP Server62MCP Server

Scrape websites and extract structured data via Firecrawl MCP.

Compare →

Session Control

Capabilities8 decomposed

mcp-based session lifecycle management

runtime limit enforcement and quota management

health check and status monitoring

security guardrails and sandboxing configuration

configurable logging and audit trail generation

dynamic configuration updates without session restart

multi-session isolation and resource sharing policies

error recovery and retry policy configuration

Related Artifactssharing capabilities

SAP ABAP MCP Server SDK

mcp-client

@browserstack/mcp-server

AWS Core

metamcp

@metorial/mcp-session

Best For

Known Limitations

Requirements

Input / Output

UnfragileRank

Repository Details

About

Categories

Alternatives to Session Control

Are you the builder of Session Control?

Get the weekly brief

Data Sources

Session Control

Capabilities8 decomposed

mcp-based session lifecycle management

runtime limit enforcement and quota management

health check and status monitoring

security guardrails and sandboxing configuration

configurable logging and audit trail generation

dynamic configuration updates without session restart

multi-session isolation and resource sharing policies

error recovery and retry policy configuration

Related Artifactssharing capabilities

SAP ABAP MCP Server SDK

mcp-client

@browserstack/mcp-server

AWS Core

metamcp

@metorial/mcp-session

Best For

Known Limitations

Requirements

Input / Output

UnfragileRank

Repository Details

About

Categories

Alternatives to Session Control

Are you the builder of Session Control?

Get the weekly brief

Data Sources