katanemo/plano

Plano is an LLM gateway and orchestration platform that routes, proxies, and manages traffic to various AI model providers. It features a Rust-based core for high-performance request handling, session-aware routing with cost controls, and multi-agent orchestration capabilities. The system also provides comprehensive observability, including real-time usage tracking, behavioral signal analysis, and provider-agnostic tracing.

24 changes.

The project was rebranded to Plano and restructured into a Rust-based WASM plugin architecture, replacing the previous Envoy-filter-centric layout. Core services including the LLM gateway, prompt gateway, and brightstaff orchestration engine were implemented in Rust, alongside a new Next.js website and standardized CLI tooling. The period focused on establishing the foundational monorepo structure, dependency management, and comprehensive test coverage for the new system.

17 changes.

This period focused on expanding the platform's LLM routing capabilities, introducing session-aware model selection, prompt caching, and cost-control budgets. It also established a comprehensive observability ecosystem with a live TUI console and behavioral signal analysis, supported by a wide array of demos covering multi-agent orchestration and advanced filtering.

A new demo located at demos/llm\_routing/chatgpt\subscription enables routing requests through a ChatGPT Plus/Pro subscription. It includes a configuration file (config.yaml) that registers a model provider for chatgpt/\ models, a Python script (chat.py) for interactive chat via the OpenAI SDK, a shell script (test\_chatgpt.sh) for testing, and documentation (README.md) explaining the setup, authentication flow, and available models (gpt-5.2, gpt-5.3-codex, gpt-5.4).

_demos/llm\_routing/chatgpt\subscription · high confidence

Brightstaff now maintains conversation history for v1/responses API calls, enabling multi-turn interactions. This change introduces a state management layer in \crates/brightstaff/src/state\ that defines a \StateStorage\ trait and provides two backends: an in-memory \MemoryConversationalStorage\ for development and a \PostgreSQLConversationStorage\ for production use. A \ResponsesStateProcessor\ intercepts streaming and non-streaming responses to capture the \response\_id\ and output items, storing the accumulated conversation state. When a subsequent request includes a \previous\_response\_id\, the system retrieves the stored history and merges it with the new input, allowing the model to maintain context across turns.

crates/brightstaff/src/state · high confidence

This change introduces the core \llm\_gateway\ crate, establishing the foundational proxy infrastructure for routing and managing LLM requests. It adds the \FilterContext\ to handle plugin configuration (including rate limits and model provider definitions) and the \StreamContext\ to manage individual HTTP request streams. The gateway now supports provider selection via hints, credential passthrough (normalizing Anthropic \x-api-key\ and OpenAI \Authorization\ headers), and upstream path modification. It also integrates the \hermesllm\ library for handling various upstream APIs (including Amazon Bedrock and SSE streams) and exposes detailed metrics such as time-to-first-token, request latency, and token throughput.

_crates/llm\gateway · high confidence

Brightstaff now includes a new agent orchestration subsystem and a dedicated routing service. The agent handlers (in \handlers/agents/\) provide an \agent\_chat\ endpoint that selects agents via an \AgentSelector\ (using an \OrchestratorService\ for multi-agent decisions), processes requests through a \PipelineProcessor\ (supporting MCP/JSON-RPC and SSE streaming), and returns structured error chains. A new \routing\_service\ handler exposes a \routing\_decision\ endpoint that parses inline \routing\_preferences\ from the request body, applies per-request budget overrides (via the \x-plano-max-switch-spend-pct\ header), and returns a decision including a ranked model list, trace/session IDs, and a \switched\ flag. Additional handlers expose a \/debug/memstats\ endpoint (jemalloc-backed when the feature is enabled) and a \/models\ listing endpoint.

crates/brightstaff/src/handlers · high confidence

This location adds a complete demo for the Plano Model Routing Service, enabling intelligent LLM selection based on user intent. The service uses a lightweight 1.5B router model (Plano-Orchestrator) to classify requests into routes (e.g., 'code\_generation', 'complex\reasoning') and returns a ranked list of candidate models, allowing clients to select the best fit or fall back on errors. The demo includes configuration files for both local and Kubernetes deployments, a metrics server for cost/latency data, and support for session pinning via the \X-Model-Affinity\ header to keep sessions on an anchor model for prompt caching. It exposes \/routing/v1/\\ endpoints for OpenAI and Anthropic formats, allowing users to test routing decisions without proxying to an LLM.

_demos/llm\_routing/model\_routing\service · high confidence

Added a new 'skills' directory containing a structured set of best-practice rules and guidelines for building agents with Plano. This framework provides coding agents (such as Claude Code, Cursor, and Copilot) with principle-based guidance on configuration, routing, agent orchestration, filter chains, observability, and deployment. The package includes an umbrella skill, section-specific skills (e.g., configuration fundamentals, routing, agent orchestration), and a build system that compiles individual rule files into a comprehensive \AGENTS.md\ guide, installable via \npx skills\.

skills · high confidence

The configuration module now supports a Redis-backed session cache for model affinity, allowing consistent model selection across multiple replicas. Users can configure the cache type as 'redis' and provide a connection URL, with an optional tenant header to scope cache keys per tenant.

crates/common/src · high confidence

This change introduces the brightstaff terminal service for LLM routing, located in crates/brightstaff/src/router. It adds a new orchestrator that uses the plano-orchestration 4b model to determine routes, supporting configurable model pricing from models.dev and DigitalOcean catalogs. The service implements session stickiness via a session cache, allowing it to retain warm anchors when switching costs exceed a defined overhead cap, and includes logic to skip re-routing on non-user turns to optimize performance. Additionally, it exposes a comprehensive set of Prometheus metrics (accessible via a dedicated /metrics endpoint) covering HTTP requests, LLM upstream calls, routing decisions, prompt caching, and session binding events, with fixed label values to prevent cardinality explosion.

crates/brightstaff/src/router · high confidence

A new Rust-based service, brightstaff, is introduced to handle LLM routing, orchestration, and session affinity. It replaces the previous arch-router and model\_server Python modules, providing a unified terminal service for LLM routing. Key capabilities include implicit session affinity based on prompt prefixes, automatic prompt caching, per-session routing budgets, and support for model aliases and wildcard models. The service also integrates with Redis for cross-replica session caching, supports v1/chat/completions, v1/responses, and v1/messages APIs, and includes observability features like Prometheus metrics, OpenTelemetry tracing, and signal analysis for conversation quality.

crates/brightstaff/src · high confidence

The new hermesllm Rust library provides a unified abstraction layer for handling LLM API requests and responses across multiple providers. It introduces type-safe provider identification and common traits for requests, responses, and streaming, allowing uniform access to properties regardless of the underlying provider format. The library currently supports OpenAI (Chat Completions and Responses APIs), Anthropic (Messages API), and Amazon Bedrock (Converse and ConverseStream APIs), enabling consistent parsing and streaming handling for these providers.

crates/hermesllm · high confidence

The \planoai obs\ module now provides an in-memory observability console that collects LLM traffic via OTLP/gRPC spans, reconstructs call details (tokens, latency, costs), and renders a live TUI. Pricing data is fetched at startup from a configurable source—DigitalOcean or models.dev—allowing the console to display real-time cost estimates for model usage.

cli/planoai/obs · high confidence

The CLI now supports running the Plano gateway natively on the host machine (using pre-built Envoy and brightstaff binaries) instead of exclusively via Docker, with automatic binary downloads and local WASM plugin handling. Additionally, a new 'planoai chatgpt' command group allows users to authenticate with ChatGPT Plus/Pro subscriptions via device code flow, enabling the gateway to route traffic to ChatGPT models using stored OAuth tokens.

cli/planoai · high confidence

The configuration schema and documentation now support a \passthrough\_auth\ option for model providers. When enabled, the gateway forwards the client's original Authorization header to the upstream service instead of using the configured \access\_key\. This allows Plano to act as a proxy for services like LiteLLM or OpenRouter that manage their own API key validation, as demonstrated in the new \test\_passthrough.yaml\ example.

config · high confidence

The prompt gateway is now available as a dedicated Envoy WebAssembly filter (located in crates/prompt\_gateway). It intercepts HTTP requests, parses OpenAI-style chat completion payloads, and routes them to configured prompt targets or upstream LLM providers. The gateway supports configurable overrides (such as agent orchestrator and context window optimization), applies prompt guards, manages tool calls, and streams responses back to the client. It also integrates with the existing metrics and tracing infrastructure, allowing for observability of active HTTP calls and request latency.

_crates/prompt\gateway · high confidence

A new test runner infrastructure has been added to \demos/shared/test\_runner\ to standardize validation across Plano demos. It includes a shell script (\run\_demo\_tests.sh\) that orchestrates demo startup via \planoai\ and optional Docker Compose, executes Hurl integration tests with retry logic (specifically for the \llm\_routing/preference\_based\_routing\ demo), and cleans up resources. Additionally, a Python test suite (\test\_demos.py\) validates API responses against the gateway endpoint, checking for expected tool calls and extracting \plano\_messages\ from response metadata. The environment is managed via \uv\ (evidenced by \uv.lock\), requiring Python 3.12+ and dependencies like \deepdiff\ and \coverage\.

_demos/shared/test\runner · high confidence

The katanemo-www application has been initialized with a new project structure. This includes a Next.js configuration (next.config.ts) that enables the externalDir experimental feature and configures webpack to resolve packages from the monorepo root (e.g., @katanemo/ui, @katanemo/shared-styles). The setup also introduces Biome for code formatting and linting, PostCSS with Tailwind CSS, and a .gitignore file. A new Katanemo logo SVG has been added to the public assets.

apps/katanemo-www · high confidence

The common API module now includes new data structures and helper functions to support advanced content processing capabilities. A new hallucination detection module provides request/response types and a message extraction utility to identify potential model hallucinations in conversation histories. Additionally, new modules define schemas for a prompt guard (supporting jailbreak and toxicity checks) and zero-shot classification, enabling the system to route and process content through these specific AI safety and classification services.

crates/common/src/api · high confidence

Added a new demo in demos/llm\_routing/codex\_router that integrates the Codex CLI with Plano to route requests to different LLM providers based on coding task type. The demo configures a 1.5B preference-aligned router to direct code generation to gpt-5.3-codex and code understanding to gpt-5-2025-08-07, while supporting additional providers like Anthropic, xAI, Gemini, and local Ollama models. Includes a shell script to monitor routing decisions in real-time.

_demos/llm\_routing/claude\_code\_router, demos/llm\_routing/codex\router · high confidence

Two new demos are now available in the getting-started directory. The LLM Gateway demo demonstrates dynamic routing to multiple upstream LLM providers (OpenAI, Anthropic, Mistral, etc.) via the Plano gateway, with optional AnythingLLM chat UI and Jaeger tracing. The Weather Forecast demo showcases Plano's function calling capabilities, featuring a FastAPI-based agent service that runs natively (via start\_agents.sh) alongside the gateway, with support for multiple observability backends (Jaeger, Logfire, Honeycomb, Signoz) and automated Hurl tests.

_demos/getting\started · high confidence

The brightstaff service now includes a new LLM request handler module that manages model selection, session affinity, and prompt caching. This handler introduces session-aware routing that can reuse prior model decisions for non-user turns to maintain cache warmth, and implements a per-session routing budget to control the cost of switching models. It also supports automatic prompt-cache marker injection for Anthropic and OpenAI providers to optimize latency and cost, while exposing detailed tracing and metrics for routing decisions.

crates/brightstaff/src/handlers/llm · high confidence

Added two new demo directories under \demos/llm\_routing/\: \model\_alias\_routing\ and \preference\_based\_routing\. The model alias demo provides configuration and scripts to map semantic names (e.g., \arch.summarize.v1\) to specific provider models, supporting both OpenAI and Anthropic clients. The preference-based routing demo demonstrates how to route requests to models based on task descriptions (e.g., 'code generation' vs. 'code understanding') using either a hosted Plano-Orchestrator or a local Ollama instance, complete with Docker Compose support for UI and tracing.

_demos/llm\_routing/preference\_based\routing · high confidence

Added two new demo applications in demos/filter\_chains/http\_filter and demos/filter\_chains/mcp\_filter that implement a RAG agent pipeline with input guards, query rewriting, and context building. The http\_filter demo exposes these agents as FastAPI REST endpoints (with streaming support for the response generator), while the mcp\_filter demo exposes them as MCP tools using FastMCP. Both demos include a sample knowledge base and support configurable LLM gateway endpoints, allowing users to test filter chain behaviors via either HTTP or MCP transports.

_demos/filter\_chains/http\_filter, demos/filter\_chains/mcp\filter · high confidence

Added three new demonstration scenarios in the \demos/advanced\ directory. The \currency\_exchange\ demo shows how to integrate a public REST API (Frankfurter) for currency conversion using prompt targets and system prompts. The \model\_choice\_test\_harness\ provides a Python-based evaluation framework (\bench.py\) and configuration to benchmark and switch between model aliases (e.g., \arch.summarize.v1\ mapping to \gpt-4o-mini\) using schema validation and anchor word checks. The \multi\_turn\_rag\ demo illustrates building a multi-turn RAG agent for energy source queries, featuring a FastAPI backend, Gradio UI, and Plano configuration for routing prompts to specific endpoints.

_demos/filter\chains · high confidence

Added a new demo in demos/llm\_routing/routing\_budget that illustrates two cost-control features: automatic prompt caching (which keeps provider caches warm within a session) and a routing budget (which limits the extra cost incurred when switching models mid-conversation). The demo includes a configuration file, a hands-on guide, and a shell script that runs multi-turn conversations to demonstrate how the budget vetoes expensive model switches while preserving cache warmth.

_demos/llm\_routing/routing\budget · high confidence

Added a new demo in \demos/agent\_orchestration/multi\_agent\_crewai\_langchain\ that showcases Plano's ability to orchestrate agents across different frameworks. The demo features a CrewAI-based flight agent and a LangChain-based weather agent, which are routed and combined by Plano into a single conversation. It includes a Dockerfile for containerized execution, a \config.yaml\ for agent definitions and routing, and scripts to run the agents natively or via Docker Compose alongside optional UI services like AnythingLLM and Jaeger for tracing.

_demos/agent\_orchestration/multi\_agent\_crewai\langchain · high confidence

The travel agents demo in demos/agent\_orchestration/travel\_agents has been restructured to support running agents natively on the host without requiring Docker for the core services. The demo now includes a Dockerfile for Python 3.14, configuration files (config.yaml and config\_local\_orchestrator.yaml) that allow users to switch between a hosted Plano orchestrator and a self-hosted local vLLM orchestrator, and a run\_demo.sh script that manages starting the agents and optional UI services (Open WebUI, Jaeger) via docker-compose. The agents (weather\_agent and flight\_agent) are implemented as FastAPI applications that communicate with the Plano orchestrator via OpenTelemetry-compatible tracing, and the demo includes REST test files for validating the agent interactions.

_demos/agent\_orchestration/travel\agents · high confidence

The \packages/ui\ package now provides a new set of React components tailored for the Plano website, including a \Navbar\ with dynamic background detection, a \Footer\ with product and resource links, and a \Logo\ component. It also includes reusable UI primitives such as \Button\ and \Dialog\ (built on Radix UI), along with utility exports like \cn\ for class merging. These components are exported from the package's main entry point, enabling consumers to easily integrate the new site-specific design system.

packages/ui · high confidence

The \crates/brightstaff/src/signals\ module now provides a Rust implementation of the behavioral quality signal analyzers, ported from the Python reference. This change introduces detectors across three layers: interaction (misalignment, stagnation, disengagement, satisfaction), execution (failure, loops), and environment (exhaustion). The \SignalAnalyzer\ orchestrates these detectors to produce a \SignalReport\, supporting both full-conversation analysis and incremental step-by-step grading. The module also includes helpers to emit these signals as OpenTelemetry span attributes and events, and preserves the legacy flag marker emoji (🚩) for downstream trace consumers.

crates/brightstaff/src/signals · high confidence

The tracing module has been refactored to support provider-agnostic span export, introducing a new PostHog exporter that translates LLM spans into PostHog $ai\_generation events. This enables first-class observability in PostHog for LLM calls, including model, provider, latency, token usage, and cost metrics. The module also adds support for custom trace attributes, allowing users to configure static attributes and header prefixes to be included in spans. Additionally, a service name override exporter enables per-span service name customization for better organization in observability backends.

crates/brightstaff/src/tracing · high confidence

The \apps/www\ directory has been restructured to use the Next.js framework, replacing the previous implementation. This change introduces a new configuration stack including \biome.json\ for linting and formatting, \components.json\ for Shadcn UI integration, and \next.config.ts\ to handle monorepo package resolution and image optimization from Sanity CDN. The update also adds standard project scaffolding files such as \.gitignore\ and \README.md\ to support the new development environment.

apps/www · high confidence

The initial project scaffolding, including the main Rust source file and its associated README, has been removed from the envoyfilter directory. This eliminates the default 'Hello, world!' application and its basic test suite, clearing the way for subsequent development or integration work.

envoyfilter · high confidence

The application now uses a centralized design system defined in the new \packages/shared-styles\ and \packages/tailwind-config\ packages. This introduces a new visual identity using IBM Plex Sans and JetBrains Mono fonts, a specific purple-based color palette, and support for dark mode. The configuration establishes a custom 3xl breakpoint (1920px) and standardizes UI tokens (colors, radii, typography) across all apps and UI packages via Tailwind CSS v4.

packages/shared-styles, packages/tailwind-config · high confidence

The session cache now uses Redis to store model affinity bindings, enabling cross-replica model affinity so that subsequent requests in a session are routed to the same model even if they hit different application instances. The implementation includes a \RedisSessionCache\ that uses a \ConnectionManager\ to automatically recover from dropped connections (such as idle timeouts or failovers) in the background, ensuring that a transient network issue does not permanently disable session affinity. A \MemorySessionCache\ is also provided as an in-memory fallback with TTL-based eviction.

_crates/brightstaff/src/session\cache · high confidence

The project has been rebranded from Arch to Plano, reflected in the new CLAUDE.md, README.md, and CONTRIBUTING.md files which update all product descriptions, documentation links, and branding. The repository structure has been reorganized to support a Rust-based WASM plugin architecture (prompt\_gateway, llm\_gateway, brightstaff) and a Python CLI, replacing the previous Envoy-filter-centric layout. A new Dockerfile establishes the build pipeline using Rust 1.93.0 and Python 3.14, incorporating security hardening by removing vulnerable packages like pip and setuptools. The workspace configuration has shifted from the legacy gateway.code-workspace to a new archgw.code-workspace that includes the Rust crates, CLI, docs, and Next.js website folders.

(repo-wide) · high confidence

The CLI now uses the \uv\ package manager instead of Poetry for local development. Users must install \uv\ and run \uv sync\ to set up the virtual environment and dependencies, and can use \uv run\ to execute commands or \uv tool install --editable .\ for global installation. A new \build\_cli.sh\ script and \uv.lock\ file replace the previous setup, and the README has been updated with these instructions.

cli · high confidence

Added REST and Hurl tests for LLM gateway, model server, and prompt gateway; Added end-to-end tests for the Plano prompt and LLM gateways; Added integration test for architecture function completion endpoint; Added signals parity test harness; Added test coverage for CLI configuration, tracing, and observability features.

This change introduces the foundational dependency manifests for the Plano project, establishing the build and runtime environments across its various components. It adds \package.json\ and \package-lock.json\ files for the Next.js-based web applications (\apps/www\, \apps/katanemo-www\) and the root monorepo, specifying dependencies such as Next.js 16, React 19, and Tailwind CSS 4. It also introduces \Cargo.toml\ and \Cargo.lock\ files for the Rust workspace (\crates/\), defining the \brightstaff\, \llm\_gateway\, \prompt\_gateway\, and other core services with their respective Rust crate dependencies. Additionally, Python dependency files (\pyproject.toml\, \requirements.txt\) are added for the CLI tool (\cli/\), configuration, and various demo applications, standardizing the project's dependency management across JavaScript, Rust, and Python ecosystems.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 61 → 60 (-0.7)
• Rubric changed (rubric-2026.09.9 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 77 → 77 (-0.4)
• Architecture 93 → 89 (-4.7)
• Maturity 77 → 77 (+0.2)
• Readiness 66 → 54 (-12.1)
• Security 55 → 66 (+10.3)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 55 → 55 (+0.0)
• Performance 100 (new)

• Critical CVE: [CVE redacted] (bun.lock)
• Critical CVE: [CVE redacted] (package-lock.json)
• Critical vulnerability: [GHSA redacted] (apps/www/package-lock.json)
• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• High CVE: [CVE redacted] (bun.lock)
• High CVE: [CVE redacted] (package-lock.json)
• High CVE: [CVE redacted] (bun.lock)
• High CVE: [CVE redacted] (package-lock.json)
• High CVE: [CVE redacted] (bun.lock)
• High CVE: [CVE redacted] (package-lock.json)
• High CVE: [CVE redacted] (package-lock.json)
• High CVE: [CVE redacted] (package-lock.json)
• High CVE: [CVE redacted] (bun.lock)
• High CVE: [CVE redacted] (package-lock.json)
• High CVE: [CVE redacted] (package-lock.json)
• High CVE: [CVE redacted] (bun.lock)
• High CVE: [CVE redacted] (bun.lock)
• High CVE: [CVE redacted] (bun.lock)
• …and 262 more

• Ambiguous Method Naming: peek_binding and get_binding have similar names and likely similar signatures (returning SessionBinding). It is unclear if peek implies a non-mutating or cheaper operation compared to get, or if they are redundant. Without documentation, this is confusing.
• Documentation: contradicts the code (docs/README.md)
• Duplicate Type Definition: Both types contain identical properties (entropy, varentropy, probability) with identical types (f64). They serve the same semantic intent of storing statistical metrics for hallucination/uncertainty analysis.
• Duplicate Type Definition: Both types contain identical properties (task_prompt, format_prompt, generation_params, support_data_types) with identical types. The only difference is the type name, suggesting a copy-paste error or unnecessary abstraction.
• Duplicate Type Definition: ShareGptMsg has a single property from: str, while ShareGptMessage has from: str and value: str. The ShareGptMsg appears to be a truncated or redundant version of ShareGptMessage. Using two different types for similar message representations creates inconsistency in the API surface.
• Duplicated block (10–11 lines × 2) (cli/planoai/core.py)
• Duplicated block (10–11 lines × 2) (cli/planoai/obs/collector.py)
• Duplicated block (11–12 lines × 2) (demos/filter_chains/model_listener_filter/content_guard.py)
• Duplicated block (12 lines × 3) (demos/filter_chains/mcp_filter/src/rag_agent/context_builder.py)
• Duplicated block (12–18 lines × 3) (demos/filter_chains/http_filter/src/rag_agent/context_builder.py)
• Duplicated block (13–14 lines × 2) (demos/filter_chains/http_filter/src/rag_agent/query_rewriter.py)
• Duplicated block (13–15 lines × 2) (demos/filter_chains/http_filter/src/rag_agent/query_rewriter.py)
• Duplicated block (14 lines × 2) (cli/planoai/trace_cmd.py)
• Duplicated block (15 lines × 3) (demos/agent_orchestration/multi_agent_crewai_langchain/crewai/flight_agent.py)
• Duplicated block (15 lines × 3) (demos/agent_orchestration/multi_agent_crewai_langchain/crewai/flight_agent.py)
• Duplicated block (15–16 lines × 2) (demos/filter_chains/http_filter/src/rag_agent/input_guards.py)
• Duplicated block (16–18 lines × 2) (demos/agent_orchestration/multi_agent_crewai_langchain/langchain/weather_agent.py)
• Duplicated block (19–22 lines × 2) (demos/agent_orchestration/travel_agents/src/travel_agents/weather_agent.py)
• Duplicated block (21 lines × 2) (demos/filter_chains/http_filter/src/rag_agent/context_builder.py)
• Duplicated block (22 lines × 3) (demos/agent_orchestration/multi_agent_crewai_langchain/langchain/weather_agent.py)
• …and 76 more

• 3 commits — 3 feature/other, 0 fixes

• crates/brightstaff — 1 commit
• crates/hermesllm — 1 commit
• docs/source — 1 commit

• change: chore(models): refresh provider models and filter non-text models (#1034)
• change: release 0.4.37 (#1037)
• change: signals: incremental analyze_step + O(1) loop detection (#1032)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

katanemo/plano was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.