Skip to content

Blog

  • in Updates
  • 2 min read

Your agent is now a connector

When Superhuman Go launched, every Pack was an agent. It defined both the instructions that shaped the agent's behavior and the tools it used to access users' data. However, we found that the approach didn't scale to more complex use cases, where an agent needs to work across multiple applications and services.

With the 1.0 launch we changed the way Packs work in Go. Instead of agents, Packs now surface as connectors. A connector provides tools, data, and skills that can be used across the platform, and agents compose them together to solve problems.

No code changes are required, and your existing agents have been converted into connectors. Some agent-specific parts of the SDK have been deprecated, and skills now work a little differently.

SDK changes

You cannot chat directly with a connector, and therefore a number of SDK features no longer make sense. The following methods have been deprecated, and no longer have any effect:

Skills are still supported, but the way they're used has changed. The LLM loads them as needed, using their descriptions to determine if they fit the task at hand. A skill's tools no longer limit what the LLM can call, but rather act as a suggestion of what to load. If a chat or bench initialization skill contained instructions still worth having, consider migrating them to addSkill() instead.

How to build agents now

Agents are now built in the agent builder, a UI for defining agents, available directly within Go. Agents built there have capabilities that weren't possible before:

  • Triggers — An agent can run automatically on a schedule, when a user is typing, or from a Slack message.
  • Multiple connectors — An agent can use as many connectors as it needs, making it possible to solve a workflow that spans several applications.

Together these make it possible to build proactive agents like Grammarly, on a custom set of connectors that bring in the data and actions your users need.

What's next

We still want to enable developers to define agents via code, and over the coming months we'll be extending the SDK to support this new style of agent. For now, keep building connectors to the applications you care about, and prototype agents using the builder.

  • in Updates
  • 2 min read

The Coda Packs SDK is now the Superhuman Packs SDK

The Coda Packs SDK has a new name: the Superhuman Packs SDK. It started out as the way to extend Coda, but over the past year it's grown into something bigger. It's also how you build agents for Superhuman Go, and going forward it will be the integration layer for everything we're building across Superhuman. The new name reflects what the SDK has already become.

What's changing

The most visible change is the one you're already looking at. The site has a new name, a new icon, and a new color palette to match the broader Superhuman brand.

You'll also notice that new code examples in our documentation import the library as sdk rather than coda:

import * as sdk from "@codahq/packs-sdk";

export const pack = sdk.newPack();

This is just a local alias, so your existing code that imports it as coda will continue to work without any changes. There's nothing to migrate, but if you do want to switch to match the new style, it's a simple find-and-replace.

What's not changing

Packs for Coda are alive and well. You can keep building them, publishing them, and shipping updates with the same workflow you've always used. All your existing Packs continue to run unchanged.

You'll also see the old name stick around in a few places. The npm package is still published as @codahq/packs-sdk, the source still lives at coda/packs-sdk on GitHub. Renaming these artifacts isn't as straightforward, so they'll likely keep the old branding for some time.

  • in Updates
  • 1 min read

Dynamic Client Registration is now supported

The SDK now supports Dynamic Client Registration (DCR) for OAuth2 authentication. With DCR, the platform automatically discovers OAuth endpoints and registers client credentials with the provider, so you no longer need to manually create an application in a developer console or upload a client ID and secret.

This is especially useful when connecting to MCP servers, many of which support DCR out of the box. Enabling it is as simple as setting a single flag:

pack.setUserAuthentication({
  type: sdk.AuthenticationType.OAuth2,
  useDynamicClientRegistration: true,
  useProofKeyForCodeExchange: true,
  scopes: ["read", "write"],
});

For more details, including how to combine DCR with manually specified endpoints, see the OAuth2 authentication guide and the MCP guide.

  • in Updates
  • 1 min read

The default LLM model is now GPT5

As of February 12, 2026, the default LLM model used by Superhuman Go agents has been updated from OpenAI's GPT-4 to GPT-5. This update brings improved reasoning and performance across agents.

If you have an agent deployed on the platform, we recommend running a quick validation to ensure everything continues to work as expected. If you would like to revert back to GPT-4, you can do so by setting the models field on your skills:

pack.addSkill({
  // ...
  models: [
    { model: sdk.SkillModel.OpenAIGPT4 },
  ],
});

You can read more about model selection in the Skills guide. We aim to provide advance notice for model updates whenever possible and we'll continue sharing updates as the Go platform evolves.

  • in Updates
  • 1 min read

Seven new SDK features for building better agents

Since the initial launch of Superhuman Go in late October, we've been busy improving the platform, including adding new features for agent developers. Here's a quick rundown of what's new:

  • MCP support - We've turned the agent platform into an MCP client, allowing your agent to use the tools exposed by an MCP server. This makes it possible to build the initial version of your agent in only a few lines of code.
  • Bench initialization - While the name of this feature is a mouthful, the idea is simple: allow the agent to start working as soon as the user has clicked on its icon in the bench. A bench initialization skill can kick off the most common user flow, show help text, or just say hi!
  • Agent logs - Developers can see detailed logs for each interaction with an agent they create, to enable better debugging.
  • Parameter validation - For agents indexing data into the knowledge layer, add parameter validation to your sync tables to ensure that users enter valid settings before kicking off the indexing process.

We've also worked to make it easier for legacy Packs to be upgraded to agents, with these new features:

  • Ingestion suggested values - Provide an alternate suggestion value for a parameter to be used in the agent setup screen.
  • Invocation source - Determine if your sync table is being run in Superhuman Go vs Superhuman Docs, to adjust the logic, etc.