← All speakers

Kim Maida

Conference affiliation: Founding GTM Engineer · Keycard · 2026

Kim Maida is Founding GTM Engineer and Head of Developer Relations at Keycard, where she works on identity and access control for AI agents. She makes authorization tangible through working applications: an agent that renews a certificate but cannot delete a database, a raffle that resists its operator’s attempt to rig it, and an expense system that distinguishes a person’s instructions from an agent’s own actions. Her work also spans browser authentication architectures and frameworks for developing and measuring developer-relations programs.

On this page

From biology to developer leadership

Kim began in animal behavior and neurobiology while teaching herself programming and building freelance web applications through high school and college. During a second course of study in human biology and dietetics, she left bioscience to program full-time. Application engineering and engineering management preceded her move into developer relations.

At Auth0, Kim progressed from content engineering to technical-content management, responsibility for the community team, and leadership of developer relations. She subsequently directed developer relations at Gatsby and became vice president of developer relations at Ionic. Her career also includes developer-relations leadership at Cloudinary and work in developer relations or documentation strategy at Okta and FusionAuth.

Kim considered returning to engineering because engineering offered a visible career ladder, while developer relations lacked comparable routes into senior positions. Her work on strategy and measurement addresses a related organizational problem: explaining how helping developers contributes to a business, without confusing the production of tutorials and events with developers actually succeeding.

Helping developers—and measuring what changes

Kim’s Developer Empowerment Flywheel connects inspiration and education with product use, sustained engagement, and community contribution. A developer who receives useful help may later teach someone else, publish a project, or contribute feedback that improves the product. Documentation, tutorials, and community programs support different stages of that progression; counting their output alone does not explain whether developers are succeeding.

Her Keystone DevRel Metrics framework approaches measurement from the business side. It starts with an outcome the company already values, such as an account registration, and relates different kinds of developer engagement to its value. At Cloudinary, Kim used registrations as the foundation; colleagues Balazs Kemenesi and Sanjay Sarathy helped validate the framework and calculations.

She has also revised her approach publicly. In a June 2025 update, Kim cautioned that organizations need different measurement strategies and described moving toward metrics organized around the flywheel. She retained the earlier framework as a practical model whose usefulness depends on the organization and what it needs to measure.

Giving software permission to act

Kim’s identity work extends from browser applications to autonomous agents. Her auth-architecture project provides runnable React and Node applications demonstrating four browser-based OAuth and OpenID Connect architectures, with a shared authorization server and resource API. Developers can examine how different arrangements of browser clients and backends handle authentication and credentials.

Agents introduce another question: whose authority does software exercise when it decides what to do next? Kim’s agent-security writing separates transport authentication, identity and delegation, policy, and runtime behavior. An authenticated connection does not authorize every action available through it. A behavioral guardrail does not identify the person who delegated access. She advocates evaluating identity, delegation, and policy before issuing a scoped credential, alongside the other security layers.

Her applications and teaching develop several concrete positions:

  • Approval cannot create authority. In It’s 10pm. Do You Know Where Your Agents Are?, an on-call agent with a broadly privileged API key can renew a certificate, restart production, and increase cloud spending using the same credential. With policy-controlled token issuance, certificate renewal succeeds, but a restart remains blocked even after Kim approves it: her user lacks the required role. Human approval is one input to the authorization decision, and cannot override the approver’s own access restrictions.
  • Decide before issuing the credential. Kim advocates using OAuth token exchange and a security token service to evaluate the agent, the delegating user, and the requested access before issuing a short-lived credential for a particular tool call. A denied request produces no new credential for that action. In Your Agent Is a Lethal Trifecta (And What to Do About It), policy prevents customer-data access and database deletion while allowing permitted work to continue. These restrictions depend on the architecture and policies; token exchange alone does not guarantee task-level access control.
  • Delegation should remain visible across services. In the Expense Desk workshop with Mason Egger, Kim demonstrates the ambiguity of API-key attribution: expenses can be filed and approved, but the ledger cannot identify the people responsible. Adding an agent identity distinguishes software acting for itself; adding user sign-in identifies the person delegating an action and allows the system to apply that person’s approval limit. A small expense is filed under the user’s identity and approved under the agent’s own authority. Separate token exchanges carry the delegation through the expense MCP server to the ledger API, preserving attribution across both steps.

Kim also describes Keycard’s proposed intent-based authorization, in which an agent proposes a mission with a goal, allowed actions, and limits. A mission to assess one incident need not permit reading every incident or changing infrastructure; a remediation mission might permit scaling a service once. She presents this as a proposal rather than a finalized standard, and distinguishes it from the task-based policy used in her demonstration. Both address permitted access; authorization does not establish that an agent’s answer or operational decision is correct.

Applications that expose the tradeoffs

Kim’s own projects put these ideas under practical pressure:

  • Plan My Today. Her planning dashboard and embedded agent, Todaygent, combine work context from calendars, email, issue tracking, repositories, chat, and meeting notes. She chose a token-mediating backend to keep downstream service credentials out of the browser. Interpreting the work required a separate intervention: missed action items and false positives in meeting notes led her to add an LLM pass for commitments expressed conversationally. Protecting service access and recognizing what someone had agreed to do required different implementation decisions.
  • Lockbox. Her live-event raffle agent makes authorization visible by inviting a human to approve an attempt to rig the draw. A deletion prohibition blocks the credential required to carry it out, despite approval. An earlier internal test exposed a failure: a product change left an outdated policy that allowed test entries to be deleted. Kim added a backup operation and used a code freeze for the live deployment. The example demonstrates an enforceable restriction while showing why the policy itself must be maintained as the application changes.

Read the topics behind these talks

3 conference talks

Loading more talks and highlights…

References