v0.8.0 - Scoped Memory System, Context Optimization, and Infrastructure Hardening

Skyflo v0.8.0 introduces a scoped, versioned memory system that persists operational knowledge across agent sessions and injects relevant context before each model turn. The release also delivers lazy toolset loading to reduce per-call token overhead, a sliding-window context manager for long conversations, Anthropic prompt caching support, and MCP startup verification with retry and backoff. Infrastructure additions include optional PodDisruptionBudgets for all services and a dedicated UI Ingress resource.

Scoped Memory System

Skyflo now has a persistent, versioned memory layer spanning the engine, MCP server, and UI. The agent automatically retrieves and injects relevant context from prior sessions before each model turn.

Data Model

Five Tortoise ORM models back the memory system (migration 4_20260508000000_add_memory.py included):

• MemoryStore: A named, scoped container for documents. Each store has a scope_type (workspace, user, conversation, environment, service) and a trust_level (admin_approved, system_seeded, user_authored, agent_draft).
• MemoryDocument: A versioned document within a store. Carries a path, title, content, doc_type (runbook, incident, pattern, preference, checklist, cluster_state, note), status, and optional entity tags.
• MemoryVersion: Immutable version history for every document write. Supports redaction of sensitive versions.
• MemorySourceRef: Structured evidence references (tool call, conversation, run ID) attached to document versions. Required when MEMORY_REQUIRE_SOURCE_REFS=true.
• ConversationMemoryUsage: Tracks which documents were injected per run, for auditability.
• DreamJob: Records agent-proposed promotion requests (drafts waiting for admin approval).

Memory Prepare Node

A new memory_prepare graph node runs between entry and model on every turn. It:

1. Extracts the latest user message as the retrieval query.
2. Calls MemoryRetrievalService.retrieve_for_turn() with entity extraction, Postgres full-text search (tsvector/tsquery), recency scoring, and entity-match scoring.
3. Enforces a configurable token budget (MEMORY_CONTEXT_TOKEN_BUDGET, default 2,200 tokens) across all retrieved documents.
4. Serializes up to MEMORY_CONTEXT_MAX_DOCS (default 6) hits into a system-injected context message and emits a memory.context.loaded SSE event.

Memory retrieval is non-fatal: if the store is unavailable or the query returns no results, the turn continues without interruption.

Agent Memory Tools

Six memory tools are exposed to the agent via the MCP server. Context values (_user_id, _conversation_id, _run_id) are stripped from the LLM-visible schema and injected by the engine at dispatch time.

Read tools (always available via default toolset):

• memory_search: Postgres full-text search over document title and content, with optional scope hints (workspace, user, environment, namespace, service).
• memory_read: Fetch a specific document by ID or path.
• memory_list: Browse documents under a store path prefix.
• memory_history: Inspect version history for a document to resolve contradictions.

Write tools (require load_toolset("memory", include_write_tools=true)):

• memory_remember: Save a durable, evidence-backed lesson with optional source references.
• memory_patch: Update an existing document with optimistic concurrency (version check).
• memory_propose_promotion: Submit an agent draft for admin review and promotion to shared memory.

All memory write tools are gated behind the load_toolset call, consistent with the lazy loading model for other mutation toolsets.

Policy and Safety

• MemoryPolicyService: Enforces read/write access boundaries based on scope type, trust level, document status, and actor type. Agents cannot overwrite admin_approved or system_seeded documents directly; they must use memory_propose_promotion.
• MemorySafetyScanner: Scans document content before persistence using Shannon entropy analysis to block high-entropy strings (credentials, tokens, keys). Limits document size to MEMORY_MAX_DOCUMENT_BYTES (100 KB) and write payloads to MEMORY_MAX_WRITE_BYTES (25 KB).

REST Management API

A new set of endpoints under /api/v1/memory/ allows operators to manage memory stores and documents directly:

Method	Path	Description
POST	/stores	Create a store
GET	/stores	List all stores
GET	/stores/{id}	Get a store
PATCH	/stores/{id}	Update a store
POST	/stores/{id}/archive	Archive a store
GET	/stores/{id}/documents	List documents in a store
POST	/stores/{id}/documents	Create a document
GET	/documents/{id}	Get a document
PATCH	/documents/{id}	Update a document
DELETE	/documents/{id}	Delete a document
GET	/documents/{id}/versions	List version history
POST	/versions/{id}/redact	Redact a version
POST	/search	Full-text search

An internal agent API at /api/v1/memory/agent/ (authenticated with INTERNAL_API_KEY) is the exclusive path for MCP tool proxying. It is not user-facing and must not be exposed publicly.

Default Store Seeding

On startup (when MEMORY_ENABLED=true), the engine idempotently creates the default stores and seeds the workspace_conventions store with Skyflo operational defaults. Seeding failures are non-fatal and logged as warnings.

Memory Context Panel

A new collapsible MemoryContextPanel component in the chat UI surfaces the documents that were injected into each model turn. It appears below the assistant response and shows each document's store slug, path, and trust level badge (admin, system, user, draft). The panel is collapsed by default and respects the spatial stability rules: it does not shift surrounding layout.

New Configuration

Variable	Default	Description
MEMORY_ENABLED	true	Enable or disable the entire memory system
MEMORY_CONTEXT_MAX_DOCS	6	Maximum documents injected per turn
MEMORY_CONTEXT_TOKEN_BUDGET	2200	Token budget for injected context per turn
MEMORY_MAX_DOCUMENT_BYTES	100000	Maximum document content size
MEMORY_MAX_WRITE_BYTES	25000	Maximum write payload size
MEMORY_REQUIRE_SOURCE_REFS	true	Require source references on agent writes
INTERNAL_API_KEY	""	Shared secret between engine and MCP; required when MEMORY_ENABLED=true

Important: INTERNAL_API_KEY must be set when MEMORY_ENABLED=true. The engine will refuse to start without it. Generate with openssl rand -base64 32. Set MEMORY_ENABLED=false to run without the memory system.

Context Window Optimization and Lazy Toolset Loading

Lazy Toolset Loading

The agent no longer receives the full tool catalog on every turn. By default, only read-only Kubernetes tools are exposed: k8s_get, k8s_describe, k8s_logs, k8s_top_pods, k8s_top_nodes, k8s_cluster_info, k8s_rollout_status, k8s_rollout_history, and wait_for_x_seconds.

A new load_toolset virtual tool lets the agent request additional capabilities on demand:

load_toolset(toolset="helm", include_write_tools=false)
load_toolset(toolset="argo", include_write_tools=false)
load_toolset(toolset="jenkins", include_write_tools=false)
load_toolset(toolset="k8s", include_write_tools=true)
load_toolset(toolset="memory", include_write_tools=true)

• include_write_tools=false loads read-only tools for that category.
• include_write_tools=true adds mutation tools (apply, patch, scale, delete, install, etc.).
• Newly loaded tools become available on the next model turn after load_toolset completes, not in the same response.

The filter_tools_by_loaded_toolsets() function resolves tool tags (from FastMCP annotations or name prefix) and filters the catalog to only the active toolsets. Tag resolution falls back to name-prefix matching (helm_*, argo_*, jenkins_*, memory_*) for tools that lack explicit tags.

Agent state now carries loaded_toolsets: Dict[str, bool], initialized to {"k8s": False, "memory": False} (read-only k8s available by default). The state is updated as the agent calls load_toolset, and is passed to tools_provider on each turn.

Sliding-Window Context Management

window_messages() in sanitization.py applies a configurable sliding window to the message history before each model call:

• Default window: 40 messages (LLM_CONTEXT_WINDOW_MESSAGES, configurable).
• System messages are always preserved.
• The first user message is always preserved as task anchor.
• The window takes the trailing N non-system messages, preserving the first user message if it would otherwise be truncated.
• Orphaned tool messages at the start of a windowed slice are dropped to avoid malformed message sequences.

This prevents context length errors on long conversations without requiring the operator to manually manage history.

System Prompt Datetime Injection

The system prompt is now generated dynamically via get_system_prompt() instead of being a static string. Each call injects the current UTC date and time (e.g., Today is Tuesday, 3rd June 2026 and the current time is 13:05). The memory search guidance in the prompt uses this temporal context to drive both undated and dated retrieval queries.

Removal of decide_next_speaker

The secondary LLM call used to decide whether the agent should continue autonomously (decide_next_speaker / NEXT_SPEAKER_CHECK_PROMPT) has been removed. The routing is now purely structural: the graph routes to final when there are no pending tool calls, eliminating a redundant model round-trip and its assoc...

v0.7.0 - Analytics Dashboard, Collapsible Sidebar, and Real-time Operational Visibility

Skyflo v0.7.0 introduces a full-featured Analytics Dashboard that gives operators real-time visibility into LLM cost, token consumption, latency, and cache efficiency across all conversations. The Command Center has been redesigned with a collapsible sidebar, real-time conversation title generation, and a comprehensive UI overhaul.

Analytics Dashboard

The new Analytics Dashboard (/analytics) provides a centralized view of operational metrics with time-range filtering and automatic bucket aggregation.

Metrics

• Total cost with per-conversation average and daily cost trend chart
• Token usage breakdown: prompt, completion, cached, and total tokens with stacked area visualization
• Time to First Token (TTFT): average latency with per-bucket area chart
• Total Response Time (TTR): average response duration with per-bucket area chart
• Cache efficiency gauge: prompt cache hit rate as a visual ratio
• Tool approval rate: approval vs. rejection counts across mutating operations
• Conversation count: total conversations within the selected period

Time Range Controls

• Preset ranges: 1h, 6h, 12h, 24h, 7d, 14d, 30d, 90d
• Custom date range picker with calendar UI
• Automatic bucket sizing: 5min to 7-day buckets depending on the selected window
• All timestamps normalized to UTC

Backend

• New GET /api/v1/analytics/metrics endpoint with last_n_days, start_date/end_date, and start_datetime/end_datetime query parameters
• MetricsAggregation and DailyMetrics response models with typed Pydantic schemas
• Aggregation computed from the Message table with fallback to messages_json for backward compatibility
• New token_usage JSONB column on the messages table (migration included) for direct per-message metric queries
• Token usage is now persisted to both the conversation JSON and the individual Message row in real time

Collapsible Sidebar

The navigation has been restructured from a top navbar with a separate history page into a collapsible sidebar.

• Sidebar contains conversation history with search, settings, integrations, and analytics navigation
• Collapses to icon-only mode to maximize the Command Center workspace
• Conversation history is now inline in the sidebar with search, infinite scroll, and cursor-based pagination
• The standalone /history page has been removed
• Sidebar state persists across navigation

Conversation Ordering

Conversations are now sorted by updated_at instead of created_at, so active conversations surface to the top. Cursor pagination uses a composite updated_at|id cursor to eliminate duplicate entries across pages.

Real-time Title Generation

Conversation titles now stream to the Command Center in real time via SSE instead of requiring a page refresh.

• New conversation.title.generated SSE event delivers the title as soon as generation completes
• Title generation is triggered after the SSE subscription is established (via on_subscribed callback) to guarantee the client receives the event
• The sidebar history updates immediately when a title is generated

MCP Health Endpoints

The MCP server health surface has been split into dedicated liveness and readiness endpoints.

• GET /health: Liveness probe. Returns 200 if the server process is running.
• GET /health/ready: Readiness probe. Verifies that kubectl, helm, and kubectl-argo-rollouts binaries are available on $PATH. Returns 503 with a list of missing tools if any are absent.
• Kubernetes manifests and Helm chart updated to use the new endpoints
• MCP probe initialDelaySeconds reduced from 60s to 10s in the Helm chart, reflecting the lighter readiness check

Helm Chart Improvements

• Conditional credentials: The engine Secret template now uses {{- with }} guards so that empty API key values are omitted entirely instead of being written as empty strings. This prevents environment variable pollution and avoids provider SDK errors from blank keys.
• Ingress support: Native Kubernetes Ingress resource with configurable host, paths, TLS, and annotation overrides for cloud load balancer integration.

CI: Kubernetes Manifest Validation

A new deployment-ci.yml workflow validates all Kubernetes manifests on every PR that touches deployment/:

• Kubeconform: Schema validation against upstream Kubernetes OpenAPI specs (skips CRDs)
• Kube-score: Best-practice scoring for security contexts, resource limits, and probe configuration
• Shell variable substitution with deterministic dummy values to render manifests before validation

Bug Fixes

• Queue drain during approval: Queued messages no longer auto-drain while tool approvals are pending. The queue pauses until all pending approvals are resolved.
• Jenkins tool detection: Jenkins tools are now identified by name prefix (jenkins_*) in addition to tag matching, preventing tools from being hidden when tags are missing.
• Jenkins input schema mutation: _strip_jenkins_input_params now deep-copies the input schema before modifying it, preventing shared-reference side effects across tool calls.

UI Revamp

• Settings: Redesigned profile and team settings with consistent layout and spacing
• Integrations: Updated component structure and visual alignment with the new sidebar navigation
• Login: Refreshed login page styling
• Welcome screen: Updated onboarding copy for the Command Center

Full Changelog: v0.6.1...v0.7.0

v0.6.1 - Helm-Native Install and Proxy Hardening

Skyflo can now be installed via Helm with a single command:

helm repo add skyflo https://charts.skyflo.ai
helm repo update skyflo
helm install skyflo skyflo/skyflo -n skyflo --create-namespace -f values.yaml

The chart packages all components (Engine, MCP, UI, Proxy, Controller, PostgreSQL, Redis) with production-ready defaults:

• Auto-generated secrets: JWT and Postgres passwords are generated on first install and preserved across upgrades via lookup
• External database support: Disable built-in PostgreSQL/Redis and point to external instances via postgresql.external.* and redis.external.*
• LLM provider flexibility: Every LiteLLM-supported provider has a dedicated API key field in engine.secrets.*
• Network policy: MCP ingress restricted to Engine pods only, with configurable egress rules for DNS and Kubernetes API access
• CRD: SkyfloAI custom resource definition for operator-managed deployments
• RBAC: Scoped ClusterRoles for the controller and cluster-admin binding for the MCP service account
• Schema validation: values.schema.json enforces engine.secrets.llmModel as a required field
• Init containers: Engine waits for PostgreSQL and Redis health before starting
• Security contexts: All containers run as non-root with dropped capabilities and RuntimeDefault seccomp profiles

The release pipeline (release.yml) now includes a publish-helm-chart job that packages the chart, updates index.yaml, and pushes to the gh-pages branch serving charts.skyflo.ai. Test releases (tags containing test) skip Helm publishing.

---

Security Headers

The Nginx reverse proxy now sets the following headers on every response:

• X-Frame-Options: SAMEORIGIN
• X-Content-Type-Options: nosniff
• Referrer-Policy: strict-origin-when-cross-origin
• Permissions-Policy: camera=(), microphone=(), geolocation=()
• Content-Security-Policy: default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'; connect-src 'self' ws: wss:; frame-ancestors 'self'; object-src 'none'; base-uri 'self'; form-action 'self';

The proxy base image has been switched from nginx:1.25-alpine to nginxinc/nginx-unprivileged:1.25-alpine, and the listen port moved from 80 to 8080 to support non-root execution. Upstream addresses are now templated via ENGINE_UPSTREAM and UI_UPSTREAM environment variables instead of hardcoded service names.

---

MCP Fix

Argo Rollout experiments are now filtered by ownerReferences (matching kind: Rollout and the rollout name) instead of name-prefix matching. This eliminates false positives when experiment names do not follow the {rollout}-{suffix} convention.

---

Deployment Changes

• Install and uninstall scripts updated for the new default namespace and resource names
• Install script sed command fixed for POSIX portability (removed -E flag)
• docs/architecture.md and docs/install.md removed from the repository (content moved to skyflo.ai/docs)

Reasoning Model Support, Deterministic Agent Rewrite, and Runtime Hardening

Skyflo v0.6.0 formalizes the deterministic execution model across reasoning, control flow, and runtime reliability. Nothing changes in production without evidence, approval, and verification.

---

Operational Guarantees

• No speculative mutations. Every remediation is evidence-backed with explicit confidence scoring.
• All mutating operations are engine-gated and authorization-enforced.
• Destructive actions (delete, drain, uninstall, abort) are annotated at the tool level and flagged before execution.
• Full reasoning chain persisted to the conversation audit trail for post-incident review.
• Version-pinned runtime dependencies with lockfile verification on every CI run.

Reasoning-Aware Execution

Reasoning is used to reduce false positives and premature mutations in production environments. The Engine auto-detects reasoning capabilities across providers (OpenAI o-series, Anthropic extended thinking, DeepSeek-R1, Moonshot/Kimi) and activates them at high effort by default. The full reasoning chain streams to the Command Center and is persisted to the audit trail.

This is not a chatbot thinking out loud. The reasoning output is structured, time-bounded, and feeds directly into the confidence scoring that determines whether the agent proceeds to remediation or continues discovery.

• Reasoning tokens stream in real time via thinking and thinking.complete SSE events
• Provider-specific handling for reasoning_content field requirements and tool call ID formats
• Configurable via LLM_REASONING_EFFORT, LLM_THINKING_BUDGET_TOKENS, and LLM_MAX_TOKENS
• LLM_TEMPERATURE has been removed. Reasoning configuration replaces it entirely.

Deterministic Control Loop

The agent prompt has been rewritten from the ground up. The previous conversational assistant has been replaced with a deterministic execution agent that enforces a strict loop on every operation:

Plan. Execute. Diagnose. Propose. Apply. Verify.

All mutating operations are engine-gated and authorization-enforced. The agent never requests textual confirmation in chat. It never pauses waiting for a "yes." It produces a structured proposal with the exact intended delta and transitions directly to execution, where the engine enforces authorization.

• Root cause confidence scoring (0-100%) determines whether the agent remediates or continues discovery
• Evidence-backed diagnosis: every conclusion must cite tool-returned fields, events, log lines, or spec values
• Incident remediation is the default posture for production failure queries
• Governance findings (restart loops, resource misconfigurations, zombie workloads) are surfaced as secondary output without delaying critical fixes

Deployment Hardening

Startup Sequencing

Startup sequencing is now dependency-aware rather than time-based. The Engine deployment includes init containers that wait for PostgreSQL and Redis to become healthy before the application starts. The previous fixed 30-second sleep in the entrypoint has been removed. Timeout is 300 seconds per dependency with explicit failure on timeout.

Health Probes

Readiness and liveness probes have been added to the UI and Proxy containers. Engine probe initialDelaySeconds has been reduced from 60s to 10s/15s, reflecting the faster startup enabled by proper dependency sequencing. A dedicated /health endpoint has been added to the Nginx reverse proxy.

Release Pipeline

The release workflow now detects test tags (containing test) and skips the latest Docker tag for test releases. Image tags are computed in a dedicated step with deterministic output.

MCP Server: Pinned Dependencies and Input Validation

The MCP server has been upgraded to FastMCP 3.x with all dependencies pinned to exact versions (mcp==1.26.0, pydantic==2.12.5, httpx==0.28.1, fastmcp==3.0.1). CI verifies the lockfile on every run via uv lock --check.

Tool input validation has been tightened:

• namespace and all_namespaces parameters are validated as mutually exclusive where applicable
• Output format and patch type parameters are normalized and validated against allowed values with clear error messages on rejection
• All validation runs before any subprocess execution

Command Center

The Command Center surfaces the reasoning chain and improves operational clarity:

• Thinking blocks: Collapsible display of model reasoning with streaming animation and duration. Collapses automatically on completion.
• Copy controls: Per-message copy with text and markdown format options for incident documentation and handoff.
• Structured tool output: Tool arguments and results containing JSON are rendered as YAML for readability. Multi-line content is visually distinguished.
• GFM tables: Proper table rendering for structured diagnostic output.

Build and Supply Chain Discipline

Pre-commit enforcement and lockfile verification are now mandatory. Formatting and linting are standardized under Ruff across engine and MCP to ensure deterministic builds and CI parity. Black has been removed. Warning rules (W) have been added to the lint selection. print() calls in the auth service have been replaced with structured logging.

API Surface

• GET /agent/tools: Returns tool metadata (name, title, annotations, tags) from the MCP server. Annotations include readOnlyHint and destructiveHint, which drive the approval gate.
• New SSE event types: thinking, thinking.complete with duration_ms for reasoning model support.
• Thinking segments are persisted to conversation history via append_thinking_segment.

Documentation

All documentation has been rewritten to reflect the deterministic execution model: README, architecture guide, installation guide, deployment reference, engine README, MCP README, Command Center README, Kubernetes controller README, and contributing guide.

Contributing

Issue assignment is now required before opening a PR. One active PR per contributor. 7-day inactivity policy for assignments and review responses. Pre-commit hooks are part of the setup process.

---

Upgrading

The LLM_TEMPERATURE environment variable has been removed. Reasoning configuration is automatic for supported models. To override, set LLM_REASONING_EFFORT or LLM_THINKING_BUDGET_TOKENS on the Engine.

MCP server dependencies are pinned. Rebuild the container image or run uv sync --frozen in the mcp/ directory.

Full Changelog: v0.5.0...v0.6.0

v0.5.0 - Release Automation, Secure Auth, and End-to-End Hardening

This release establishes production-grade foundations across authentication, release automation, build reproducibility, and deployment UX.

What began as release automation work expanded into a full end-to-end product hardening and systems revamp, spanning infrastructure, security, runtime correctness, and user experience.

Skyflo.ai now ships with deterministic builds, enterprise-grade authentication, versioned releases, and a significantly improved installation and operations experience.

---

🎯 Highlights

• Secure refresh-token–based authentication with short-lived access tokens
• Tag-based, multi-arch Docker releases with consistent version propagation
• Fully reproducible builds via lockfiles and pinned tooling
• One-line production install with automatic release detection
• Strict CI quality gates across engine, MCP, and UI
• Cleaner deployment UX with safer install and uninstall flows
• Continued UI and engine improvements from the community

---

🔐 Authentication Security

• Reduced JWT access token expiry from 1 week → 15 minutes
• Implemented refresh token rotation with 7-day expiry
• Added RefreshToken model with SHA-256 hashed storage
• New endpoints:
  • /auth/refresh
  • /auth/refresh/issue
  • /auth/logout
• UI schedules silent token refresh before expiry
• Tokens stored in httpOnly cookies

---

🚀 Release Automation

• Version tags (v*) trigger multi-arch Docker image builds (amd64 / arm64)
• Images published with:
  • version tag
  • short SHA
  • latest
• APP_VERSION build arg flows through all Dockerfiles into runtime
• Installer auto-fetches the latest release from the GitHub API
• All components receive consistent versioning
• Installation script streamlined and documentation improved for local setup (community contribution)

---

🧱 Reproducible Builds

• Switched Python builds to uv with frozen lockfiles
• Pinned tooling inside MCP image:
  • kubectl v1.35.0
  • argo-rollouts v1.8.3
  • helm v4.1.0
• Pinned runtime dependencies:
  • Redis 7.4.7-alpine
  • Postgres 15.15-alpine
• Removed .env copying from Dockerfiles to avoid implicit state

---

⚙️ Production Configuration

• Split runtime configuration into per-service ConfigMaps
  • engine
  • mcp
  • ui
• Restructured Secrets with consistent naming and envFrom injection
• Installer now auto-generates secure Postgres credentials
• Clear separation of non-sensitive defaults vs secrets

---

✅ CI Quality Gates

• CI workflows now run on every PR:
  • Engine: lint
  • MCP: lint, type-check, tests
  • UI: lint, build
• Enabled ruff and mypy with targeted rules
• Fixed all blocking lint and type errors across the codebase
• Fixed kubectl argument handling for commands with spaces:
  • patch
  • exec
  • run
  • get

---

🔌 MCP Server Improvements

• Added health endpoint: /mcp/v1/health
• Configured liveness and readiness probes in manifests
• Added fastmcp.json for MCP client integrations
• Improved MCPClient cleanup and lifecycle handling (community contribution)
• Renamed utils/types.py → utils/models.py for clarity

---

🎨 UI & UX Improvements

• Added TPS (tokens per second) metric to token usage display (community contribution)
• Fixed message continuity after tool approval/denial in chat (community contribution)
• Improved streaming and refresh behavior across chat interactions
• Removed unused UI components and tightened rendering behavior

---

🐞 Bug Fixes

• Fixed rate limiter to use noop dependency when disabled
• Resolved Redis client initialization race with async lock
• Fixed workflow cancellation and cleanup in SSE agent streams
• MCP client now returns structured errors instead of raising
• History refresh preserves active search query
• Integration edits preserve metadata when unchanged
• Hide token usage while messages are still streaming
• Allow superusers to access admin-only team and integration endpoints

---

🧭 Deployment UX

• New one-liner install:

curl -fsSL https://skyflo.ai/install.sh | bash

• Installer prompts for version selection and auto-detects releases
• Uninstaller supports optional PVC cleanup
• Cleaner, more structured CLI output

---

🧹 Code Cleanup & Hygiene

• Improved exception chaining (raise ... from e) across codebase
• Standardized imports across Python modules
• Improved contributing guidelines and documentation
• Added TRADEMARKS.md policy document

---

🧪 Testing

• Verified refresh token lifecycle: issue, rotate, revoke
• Published test release and validated Docker image publishing
• Installed on a clean KinD cluster using auto-detected version
• Confirmed all CI checks pass locally
• Verified uninstall preserves PVCs when declined
• Validated MCP health endpoint for Kubernetes probes
• Tested rate limiter behavior with RATE_LIMITING_ENABLED=false

---

⚠️ Breaking Changes

• Secrets renamed:
• skyflo-secrets → skyflo-engine-secrets
• skyflo-postgres-secrets
• Existing deployments must be uninstalled and reinstalled to pick up new ConfigMaps and Secrets

---

🤝 Contributors

Thank you to everyone who contributed to this release:

• @nitishbhosale7 – installation script refactor and local setup improvements
• @Mahadevan2005 – UI token metrics (TPS) enhancement
• @Sachin-chaurasiya – chat continuity fixes after tool approval/denial
• @vikasgoswami2 – MCP client cleanup and lifecycle fixes

Your work raised the bar for this release.

---

Full Changelog:
v0.4.0...v0.5.0

---

Final note

v0.5.0 sets the baseline for Skyflo.ai going forward:
enterprise-grade defaults, reproducible systems, and no partial correctness.

v0.4.0 - Real-time Metrics, Streamable HTTP, and Jenkins Control

This release brings real-time visibility into LLM performance with live token usage tracking, migrates the MCP infrastructure to a robust HTTP transport, and adds critical control features for Jenkins workflows.

🎯 Key Improvements

• Real-time Token Metrics: Live display of token usage, Time to First Token (TTFT), and Time to Respond (TTR) directly in the chat interface.
• Streamable HTTP Transport: Migrated the entire MCP architecture from SSE to FastMCP's Streamable HTTP transport for better stability and stateless operation.
• Jenkins Build Control: New capabilities to stop/cancel running builds and fetch job parameters before triggering, enabling smarter CI/CD interactions.
• Testing Infrastructure: Added a comprehensive pytest suite for the MCP server to ensure tool reliability.
• UI Enhancements: Refactored tooltip components and improved message rendering performance.

🔍 Detailed Changes

Engine

• Metrics System:
  • Tracks and emits ttft, ttr, and token.usage (prompt, completion, cached) events.
  • Persists usage metrics alongside conversation history.
• MCP Client: Refactored MCPClient to use StreamableHttpTransport and removed manual lifecycle management.
• Prompts: Updated system prompt to enforce parameter fetching before triggering Jenkins jobs.

MCP Server

• Transport: Switched default transport to HTTP on port 8888; removed legacy SSE flags.
• Jenkins Tools:
  • jenkins_stop_build: Stop or cancel running builds.
  • jenkins_get_job_parameters: Inspect job parameters before building.
• Testing: Added pytest suite covering Argo, Helm, Jenkins, and Kubectl tools (mcp/tests/).

UI

• Token Usage Display: New component TokenUsageDisplay shows live cost and latency metrics in the chat footer and per-message.
• SSE Service: Updated to handle new metric event types (token.usage, ttft).
• Components: Refactored Tooltip to use Radix UI for better accessibility and performance.

Deployment

• Ports: Standardized MCP server on port 8888 across all install manifests (Docker, K8s).
• Configuration: Updated install.sh and docs to reflect the new transport architecture.

v0.3.2 - Batch Approvals, Liquid Composer, and SSE Hardening

This release introduces bulk approval controls for tools, a redesigned “liquid glass” chat composer, and hardened streaming defaults for reliable long-running SSE sessions.

🎯 Key Improvements

• Batch Approvals: Approve or decline multiple pending tool executions in one action with live progress. Individual approval controls are safely disabled during a bulk run.
• Liquid Glass Composer: Modernized chat input with a layered glass effect, new "top slot" to host queued prompts and pending-approval controls, and refined header visuals.
• Streaming Reliability: NGINX proxy tuned for long-running SSE: extended read/send timeouts, disabled proxy buffering, and enabled chunked transfer.
• Kubernetes Rollbacks: New tools to view rollout history and rollback deployments/daemonsets/statefulsets.
• Dependency Pin: Pinned aerich==0.8.2 for predictable migration behavior.
• Image Metadata: Updated OCI description labels from "Cloud Native" to "Cloud & DevOps" across services.
• Install Version: Bumped installer to v0.3.2.

🔍 Detailed Changes

Engine

• pyproject.toml: Pin aerich==0.8.2 to stabilize migration tooling.

MCP Server

• Kubernetes tools (mcp/tools/kubectl.py):
  • k8s_rollout_undo: Roll back to previous or specific revision.
  • k8s_rollout_history: Inspect rollout history, optionally for a specific revision.

UI

• Composer & Visuals:
  • Added liquid-glass CSS utilities in ui/src/app/globals.css and SVG filter in ui/src/app/layout.tsx.
  • Page title updated to "AI Agent for Cloud & DevOps"; header tagline refined.
• Chat Experience:
  • ChatInput now supports a topSlot to render contextual bars inside the composer.
  • New QueuedMessagesBar shows and controls queued prompts inline.
  • New PendingApprovalsBar enables approve/decline-all for pending tools with progress state.
  • ChatInterface wires bulk approval sequencing and disables per-tool actions while running; merges incremental tool execution updates more robustly.
  • ChatMessages and ToolVisualization accept disableActions to honor bulk-run locks.
  • sseService: marks awaiting_approval tool events with requires_approval.
  • UI README lists the two new chat components.

Deployment

• Docker image labels: Updated descriptions to "Cloud & DevOps" in Engine, MCP, and UI Dockerfiles.
• NGINX (UI): Added proxy_read_timeout 3600s; proxy_send_timeout 3600s; proxy_buffering off; chunked_transfer_encoding on; for resilient SSE.
• Installer: install.sh version set to v0.3.2.

v0.3.1 - Chat Message Queuing System

This release focuses on a smoother chat experience, faster history discovery, and better Kubernetes tooling for the agent.

🎯 Key Improvements

• Chat Message Queuing: Send multiple prompts while a response is streaming. Messages queue in a compact footer; you can remove items or submit one immediately, and the queue auto-drains when streaming finishes.
• Server-Side History Search: End-to-end backend filtering with cursor-based pagination; the UI uses debounced search for responsive results.
• Helm Template Tool: Preview rendered manifests without installing a chart.
• Kubernetes Tools Enhancements: Richer kubectl logs options and label-based filtering in kubectl get.
• Navbar UX: Logo now navigates home; added quick link to the GitHub repo.

🔍 Detailed Changes

Engine

• GET /api/v1/conversations now supports a query parameter to filter conversations by title (case-insensitive). Works with cursor pagination and enforces sane limits.

MCP Server

• Helm: Added helm_template tool to render Helm charts without installing. Supports namespace, values content (via a temp file), and --include-crds.
• Kubernetes:
  • k8s_logs: new options container, since, previous, plus configurable --tail lines.
  • k8s_get: new label_selector option for server-side resource filtering.

UI

• Chat:
  • Message queuing interface in ChatInterface shows the queue, allows removal or “submit now,” and auto-drains when streaming finishes.
  • Footer height tracked with ResizeObserver to keep scroll padding correct while the queue appears/disappears.
• History:
  • True server-side search wired end-to-end (/api/conversation?query=...) with intersection-observer pagination.
  • Debounced search input using a new utility (ui/src/lib/debounce.ts).
  • Improved empty states and refresh behavior; removed client-only filtering to avoid stale lists; deduplicates conversations across pages.
• Navbar:
  • Logo button navigates to /.
  • Added GitHub icon linking to the project repository.
• API route passthrough: The Next.js route for conversations forwards the query parameter to the engine.

Reliability & UX

• Query input is trimmed and only sent to the backend when it has at least 2 characters to reduce unnecessary requests.
• History fetching preserves pagination integrity when searching and prevents duplicate items.

🤝 Contributors

Thank you to our contributors for making this release possible:

@joonseolee @Sachin-chaurasiya

v0.3.0 - Jenkins Integration Support

We now support Jenkins as an external integration, making Skyflo.ai the ideal AI co-pilot for Cloud & DevOps that unifies Kubernetes operations and CI/CD systems behind a natural-language interface.

🎯 Key Improvements

• Jenkins Tools (MCP): Comprehensive Jenkins toolset (jobs, builds, logs, SCM, identity) with robust auth and CSRF handling.
• Integration Framework: New integrations foundational setup for making it easy to add more integrations in the future.
• Credential Security: Secure way of storing and passing credentials for integrations to the MCP server.
• Smart Tool Execution: Integration-aware tool filtering and automatic parameter injection for LLM tools.
• Minor bug fixes and improvements: Various bugs were fixed and improvements were made to the overall experience.

🔍 Detailed Changes

Engine

• New endpoints: POST/GET/PATCH/DELETE /api/v1/integrations (admin-only)
• Jenkins Integration: Added jenkins as an integration.
  • Uses kubectl_apply and kubectl_delete to create and delete the Kubernetes Secret containing the credentials.
• Models: Integration (provider, name, metadata, credentials_ref, status, FK to user)
• Settings: INTEGRATIONS_SECRET_NAMESPACE (default default; .env.example sets skyflo-ai)
• Tool Executor:
  • Filters tools based on configured integrations (e.g., hides Jenkins tools if not configured/disabled)
  • Injects required params (e.g., api_url, credentials_ref) automatically when available
  • Emits tool.error SSE events when integrations are missing or disabled
• System Prompt: Updated the system prompt to include instructions for external integrations like Jenkins.

MCP Server

• Jenkins toolset: Added mcp/tools/jenkins.py with job, build, log, SCM, and identity operations (uses httpx)
• Kubernetes tools:
  • k8s_apply now accepts manifest content via stdin (safer, simpler)
  • Removed k8s_manifest_write (no longer needed)
  • run_command supports stdin piping
• Config: Jenkins tools registered in MCP server config; new dependency httpx

UI

• Integrations Page: ui/src/app/integrations/page.tsx + ui/src/components/Integrations.tsx
  • Create/Update/Delete integrations, set status, edit credentials
  • Secure UX: credentials fields optional on edit (token not echoed)
• Modals: InputModal generalized to form-based children; ConfirmModal supports sizes
• History UX:
  • Rename modal uses FormData to improve form handling
  • Removed transform hover effect from the conversation cards

Security & Reliability

• Secrets: Credentials stored as Kubernetes Secrets; resolved by a reference to the Secret in the engine.
• Sanitization: Sensitive fields are stripped from the SSE event payloads.
• Resilience: Clear guidance and error events for integration connectivity issues (timeouts, TLS, 401/403)

v0.2.0 - Complete Platform Overhaul

Skyflo.ai has been completely rebuilt from the ground up to deliver a smarter, faster, more cost-effective, and user-friendly AI agent experience for Cloud Native operations.

🎯 Key Improvements

• Unified Agent Workflow: Replaced complex multi-agent system (Planner-Executor-Verifier) with a single, efficient LangGraph workflow
• Simplified Communication: Moved from WebSocket to Server-Sent Events (SSE) for reliable real-time streaming
• Workflow Checkpointer: Resume interrupted workflows instantly from any point with persistent state management
• Streamlined MCP Server: Consolidated dual-server architecture into a single FastMCP server
• Enhanced Chat Interface: Improved real-time message rendering with better tool visualization
• Resource Efficiency: Significantly reduced memory footprint and processing overhead
• Deployment Flexibility: Skyflo.ai can now be installed in any namespace