February 2026 Summaries

Chat builder kits, such as CopilotKit, OpenAI ChatKit, and Gram Elements, offer enhanced functionality beyond traditional chatbots by integrating AI agents that can execute functions, update states, and trigger workflows through natural language interactions. Each framework is designed to connect user interfaces with AI agents in unique ways, impacting integration complexity, state management, customization options, pricing models, and observability. CopilotKit, being open-source, provides the most control over state synchronization and UI customization, allowing agents direct access to app states, but involves complex hook definitions. OpenAI ChatKit, suitable for those already using the OpenAI ecosystem, requires setup through the OpenAI platform and involves unpredictable pay-as-you-go pricing based on token usage, but offers a streamlined integration process. Gram Elements focuses on production observability with detailed session insights and a predictable tiered pricing model, though it limits state management to MCP server interactions. Each framework's capabilities and limitations make them suitable for different use cases, such as content-heavy SaaS deployments, rapid integration within existing ecosystems, or large-scale production monitoring.

AI transformation is emerging as the new digital transformation within enterprises, requiring a shift in how companies evaluate and integrate software tools. This shift focuses on whether tools can be operated end-to-end by agents, rather than humans, to enhance scalability, efficiency, and automation. Current vendor evaluation criteria often lag behind, still favoring human-operated tools with polished UIs and feature checklists, rather than those designed for agent operation. The emerging demand is for agent-native products, which allow complete automation of workflows through CLIs, APIs, and deterministic outputs. The evolution towards agent-native tooling not only changes engineering paradigms but also empowers non-developers to build software-like solutions, leading to greater organizational productivity and larger budgets for AI transformation. However, adopting agent-native tools involves trade-offs, including increased operational responsibility and the need for robust internal platforms. Organizations that adapt their evaluation and procurement processes to accommodate agent-native tools will likely gain compounding capabilities over those that continue to rely on human-centric software solutions.

Terraform Speakeasy v1.726.0 introduces internal architectural enhancements to its generation engine, resulting in significant performance improvements for Terraform provider generation, including a 22% faster generation time, a 36% reduction in CPU usage, and a 32% decrease in peak memory consumption. These improvements are especially pronounced for providers with complex schemas and high resource counts, where memory usage reductions can exceed 50%. The optimizations stem from changes such as an improved generator architecture to reduce serialization overhead and parallelized template file outputs. These enhancements allow for faster feedback loops and lower compute costs without requiring any workflow changes or impacting the generated provider code, making the updates backward compatible and seamless for developers.

In the ongoing debate between using skills or MCP servers for AI agent extensions, the text argues that both are essential components of a comprehensive AI tooling strategy. Skills represent static, curated patterns or instructions that guide agents in executing tasks, while MCP servers provide live, authenticated access to systems and real-time data. By employing a two-layer architecture, organizations can ensure that skills offer judgment and expertise, while MCP servers grant the ability to interact with live services securely. The text emphasizes that this dual-layered approach avoids the pitfalls of relying solely on either skills or MCP servers, highlighting the importance of both in managing security, observability, and organizational governance. The future may see a convergence of skills with well-written documentation as AI agents improve in processing large documents, but the need for MCP servers to handle authentication and access to live systems will remain critical.

Terraform has introduced support for ephemeral resources and actions in its provider generation, enhancing its capabilities to handle temporary data and automate day-2 operations without persisting sensitive information to state. Ephemeral resources, introduced in Terraform 1.10, allow providers to manage temporary or sensitive data like secrets and tokens without storing them in the state file, addressing long-standing challenges of maintaining data security. Actions, introduced in Terraform 1.14, enable the integration of day-2 operational tasks such as backups or service restarts directly within Terraform, eliminating the need for external scripts or manual API calls. Both features utilize the x-speakeasy-entity-operation extension, maintaining consistency and familiarity with the existing configuration model, and support multiple API operations to accommodate complex workflows. These enhancements represent a significant step towards achieving feature parity between SDK and Terraform provider generation while ensuring backward compatibility.

Ruby SDKs generated by Speakeasy have introduced open enums and smart union deserialization to enhance compatibility and flexibility when interacting with evolving APIs. Open enums allow older SDK versions to handle new enum values without crashing by treating unrecognized values as raw strings, while smart union deserialization improves the selection of appropriate union variants by considering the number of matching fields rather than relying on declaration order. These features ensure that SDKs remain operational as APIs evolve, eliminating the need for users to modify their code to accommodate new enum values or union variants. By default, response enums can be configured to be open, and the populated-fields strategy for union deserialization can be set to prioritize variants with the most field matches, providing a robust solution for handling API changes seamlessly.

SDK generators, which automatically create language-specific client libraries from API specifications like OpenAPI, are crucial for simplifying API integration and improving developer experience. This detailed comparison of five popular SDK generators—OpenAPI Generator, APIMatic, Fern, Stainless, and Speakeasy—highlights their unique strengths and limitations. OpenAPI Generator is acclaimed for its extensive language support and open-source nature but requires significant maintenance. APIMatic offers an integrated developer portal and affordability but lacks language diversity and runtime type safety. Fern, backed by Postman, integrates SDK and documentation generation but uses a custom DSL, posing compatibility challenges. Stainless, favored by AI companies like OpenAI, provides robust features but relies on a custom configuration layer. Speakeasy, recommended for its balance of quality, features, and flexibility, emphasizes runtime type safety, minimal dependencies, and OpenAPI fidelity, catering to enterprises needing comprehensive language support and adaptable deployment options.

The Model Context Protocol (MCP) has emerged as a vital standard for connecting AI agents to APIs and data sources, gaining traction since its introduction by Anthropic in 2024. As MCP becomes more widely adopted, organizations face the challenge of generating production-ready MCP servers from existing API specs. This piece compares three prominent approaches: Speakeasy, Stainless, and Postman, each evaluated on automation, type-safety, deployment flexibility, protocol support, and developer experience. Speakeasy focuses on automation and customization, supporting various protocols and offering both managed and self-hosted options. Stainless provides a code-execution model within its TypeScript SDK, emphasizing code-mode execution for complex workflows but can add overhead for simpler interactions. Postman offers a unique perspective by leveraging its extensive API Network, providing quick access to public APIs without custom coding but lacking some of the advanced features of Speakeasy and Stainless. Ultimately, the choice between these tools depends on specific organizational needs such as protocol requirements, hosting preferences, API size, authentication methods, workflow automation, and the necessity for centralized gateways.

Speakeasy, a company focused on optimizing product presentation for both humans and machines, recently assessed its own website's readiness for AI agents and discovered significant challenges in accessibility and navigation due to heavy use of React and complex site structure. As AI agents, such as chatbots and virtual assistants, are becoming increasingly important for discovering and interacting with content, Speakeasy transitioned its site to support markdown format, facilitating better parsing and understanding by these agents. Markdown, being context-rich and familiar to LLMs, allows for more efficient information delivery compared to traditional HTML. Speakeasy implemented an API endpoint to serve markdown content directly, enhancing agent readability and creating an llms.txt file to index these resources, despite uncertainty about its current utilization by LLM providers. The company also introduced an "agent mode" toggle to illustrate the disparity between human and machine-readable content, underscoring the importance of machine-readability for future-proofing web content. Speakeasy's approach reflects a proactive stance on the shifting landscape of content consumption driven by AI, emphasizing the low cost of early adoption against the potential future benefits.

Granary is an open-source command-line tool designed to enhance the coordination and memory of AI agents working on large codebases by providing a shared memory layer. Developed by Speakeasy, it addresses common issues in multi-agent workflows, such as loss of context between sessions, duplicated efforts, and conflicting changes, by offering a structured framework that includes planning, execution, coordination, and handoff phases. Granary ensures efficient context management, concurrency safety, and event-driven automation, making it easier for AI agents to work collaboratively on tasks like code reviews, migrations, feature development, and bug investigations. The tool is built in Rust, operates locally with SQLite for centralized data storage, and is fully open source under the MIT license, inviting community contributions to expand its functionality. Granary can be quickly installed and initialized within a project, providing a seamless and autonomous workflow environment that eliminates the need for human intervention in task transitions.

APIs are crucial to modern software, and as OpenAPI specifications grow in complexity, existing linters like Spectral and Vacuum face performance challenges with large specs. Spectral, while popular, struggles with scale and requires Node.js, whereas Vacuum, although faster and Go-native, consumes more memory. In response, Speakeasy developed its own OpenAPI linter, part of their openapi CLI, aiming for a balance of speed, memory efficiency, and thoroughness. Their linter, built on a Go library, outperforms alternatives in benchmarks, finding more issues while using less memory and maintaining no runtime dependencies. Despite having fewer built-in rules and output formats, it excels in handling large specs efficiently. Speakeasy's linter reflects a commitment to ongoing development, seeking user feedback to improve its ecosystem and expand its rule set.

Publishing Python SDKs to PyPI has become more secure and efficient with the introduction of trusted publishing, which utilizes OpenID Connect (OIDC) to establish a trust relationship between PyPI and GitHub Actions workflows. Unlike traditional methods that rely on long-lived API tokens prone to leaks and requiring manual rotation, trusted publishing generates short-lived tokens at publish time, reducing security risks and maintenance efforts. Speakeasy supports PyPI trusted publishing through either an automatic setup using its CLI, which simplifies the process, or a manual configuration for those who prefer detailed control. This approach ties each publish to a specific commit, workflow run, and repository, enhancing auditability and eliminating the need to manage or rotate stored credentials. Setting up trusted publishing involves configuring the GitHub workflow permissions and adding a publish-pypi job, with further configuration needed on PyPI to designate GitHub Actions as the trusted publisher. The transition to trusted publishing not only simplifies the workflow but also aligns with the Python packaging ecosystem's move towards improved security practices.

In a rapidly evolving API landscape, the article discusses a strategy employed by Speakeasy for managing SDKs to balance strict validation during development and flexibility in production. This approach, inspired by Postel’s Law, involves implementing strict validation in controlled environments like CI pipelines to catch schema drift and contract violations early, while adopting a more permissive lax mode for external SDKs to ensure forward compatibility and prevent customer applications from crashing. By doing so, unknown values are preserved rather than causing errors, which allows for graceful degradation when APIs introduce new values or union types. This method not only aids in faster feature shipping and reduces support issues but also enhances the overall developer experience by maintaining a robust type system without sacrificing runtime adaptability. Speakeasy's implementation of this model with TypeScript SDKs demonstrates a pragmatic solution to the challenges of API evolution, ensuring that customers experience fewer disruptions while also benefiting from strong type safety and forward compatibility.

Speakeasy faced challenges adapting its Command Line Interface (CLI) for AI agents, which initially was designed with human users in mind, featuring interactive prompts, visual feedback, and guided workflows. While these features enhanced human interaction, they hindered AI agents, which struggled with prompts and found visual feedback as noise. To address this, Speakeasy introduced non-interactive flags to bypass prompts, structured output for machine readability, and machine-readable exit codes. Additionally, they developed "skills," lightweight markdown files that guide agents in using the CLI, enabling them to navigate complex workflows effectively. These efforts were part of making the CLI compatible with both human and AI users, recognizing the increasing use of CLIs by AI agents in development environments. The company emphasizes the importance of designing tools that cater to both humans and agents, ensuring seamless integration into developer workflows.

An MCP gateway centralizes AI agent-tool connections to address the integration challenges of managing multiple OAuth implementations and audit trails across numerous servers and agents. There are three primary types of MCP gateways: infrastructure-first, which focus on routing and deployment with basic governance features; governance-first, which emphasize enterprise controls like audit trails and compliance; and hybrid gateways that combine governance with managed integrations or deployment services. These gateways differ from API gateways as they handle stateful workflows and enforce policies at the function and parameter level, introducing unique capabilities like semantic policies, human-in-the-loop workflows, and identity mediation. The choice of an MCP gateway depends on specific needs, whether for routing infrastructure (such as Microsoft and Docker), enterprise compliance (such as TrueFoundry and Lunar.dev), or prebuilt integrations (such as Composio and Gram). Gram also offers unique functionality by generating MCP servers from OpenAPI documents, facilitating efficient toolset creation and serverless deployment.

The blog post explores the landscape of MCP (Model Context Protocol) gateways, focusing on four solutions: Gram, Composio, TrueFoundry, and Docker MCP Gateway. Each tool is tailored to different needs, such as Gram's ability to generate MCP servers from REST APIs and provide an intuitive setup, making it ideal for quickly building products. Composio offers over 500 managed integrations, excelling in chat workflows but lacking in custom server support. TrueFoundry stands out with its advanced governance and compliance features, catering to enterprises in regulated industries, although it may be overly complex for smaller teams. Docker MCP Gateway provides full infrastructure control through container orchestration, appealing to teams already embedded in Docker ecosystems, but requires significant setup and maintenance expertise. The post emphasizes selecting an MCP gateway based on the specific needs of building new servers or managing existing ones, considering factors like integration capabilities, governance controls, and setup complexity.

AI agents are becoming crucial tools for development, yet they often face challenges in specialized areas like OpenAPI and SDK generation due to reliance on potentially outdated training data. To address this, a collection of agent skills has been introduced to enhance AI assistants' capabilities in working with OpenAPI specifications and the Speakeasy CLI. These skills are essentially markdown files that provide specific instructions and are triggered by relevant tasks, ensuring agents have the necessary context. The skills cover a wide range of API development aspects, from writing OpenAPI specs to generating SDKs across multiple languages, and are designed to be lightweight and easy to integrate. The approach focuses on creating small, targeted skills rather than broad ones, as this has been shown to be more effective. These skills not only improve API specs but also reduce the barriers for developers using the Speakeasy toolchain by providing clear guidance without needing extensive documentation review. The open-source nature of the repository allows for ongoing iteration and contributions from the community.