twimco.Let’s talk ↗︎
Menu
Field notes / Product & engineering

Google's agent kit made agent-to-agent calls stable. Write your agent card like a contract before another team calls it

For most of this year, one agent calling another was a demo. With ADK 2.14, Google moved its A2A support out of experimental and added a command that writes the agent's public description for you. That description is about to become the thing other teams build against, so it's worth writing on purpose.

Editorial engraving of a bright meeting nook where an engineer with a braid stands reading a printed card while a procurement lead writes on a short contract at a sideboard.

Google's Agent Development Kit for Python 2.14.0, released the evening of November 6, 2026, makes its A2A (agent-to-agent) integration stable and adds adk generate_agent_card to build an agent card from the CLI. If other agents will call yours, treat that card as a contract: name each skill narrowly, say what the agent will refuse, set authentication, decide who owns changes, and test cancellations and failures before anyone depends on it.

What changed in ADK 2.14

Google's Agent Development Kit is the framework a lot of teams use to build agents on Google Cloud and elsewhere. Version 2.14.0 of the Python kit went out on the evening of November 6, Eastern time, and the release notes read like a graduation list. Execution environments, evaluation, core runtime modules and the A2A integration all move out of experimental. Twenty-six modules and sixteen toolset and integration features are now marked stable, "so you can build on them without experimental warnings."

A2A is the agent-to-agent protocol: a standard way for one agent to discover another, read what it offers and send it a task. ADK 2.14 adds a command, adk generate_agent_card, that builds the agent card for you. The card is the public description another agent reads to decide whether and how to call yours: its name, what it can do, where to reach it and how to authenticate.

The release also carries a set of smaller fixes that matter once agents talk to each other. Cancelling a task now propagates to the run that's doing the work. Failed A2A tasks are marked as error events. The remote client sends the A2A version header every time and presents an mTLS client certificate from its default client. And on evaluation, adk eval --num_runs runs each case several times and combines the scores.

Who should care now? Teams with more than one agent in production, where a support agent asks an inventory agent, or a planning agent hands work to a research agent. Companies thinking about letting a partner's agent reach theirs, such as a supplier's ordering agent talking to your stock agent. And anyone who has been holding off on A2A because the word "experimental" made it hard to justify. That last reason is now gone, which is exactly when it's worth slowing down for a day.

The card is a promise, not a summary

Whatever your agent card says it can do, someone will eventually ask it to do.

Inside one team, an agent's abilities are whatever its tools allow, and the people using it know the unwritten limits. The moment another team's agent can read your card and send tasks, those unwritten limits disappear. The calling agent doesn't know that "update customer record" was only meant for address changes. It sees the skill and uses it.

A generated card is a fine starting point, because it shows you what the agent claims today. It is not a finished contract. Generators describe capability. A contract describes commitment: what you will support, for whom, and what happens when it goes wrong.

Decision guide

Generated card, or reviewed card

ConsiderationWhat a generator gives youWhat a reviewed card adds
SkillsEverything the agent's tools make possibleOnly the jobs you're willing to support for other teams
DescriptionsPhrasing lifted from code and promptsPlain sentences, including what each skill won't do
AccessWhatever the default deployment allowsNamed callers, authentication, and mTLS where it matters
ChangeRegenerated whenever the code changesVersioned, with an owner and notice to callers
Decision framework: assess against who will call your agent and what it can reach.
Whatever your agent card says it can do, someone will eventually ask it to do.

Write the skills narrowly

Go through each skill on the card and ask whether you're willing to support it for callers you don't know yet. Cut the ones you aren't. For the rest, rewrite the description so a careful stranger would understand it. Say what the skill does, what it needs, and what it will refuse. "Looks up order status by order number. Does not change orders, issue refunds or return customer contact details" is a better description than anything lifted from a function docstring.

A small example makes the point. A support team builds an agent with three tools: look up an order, update a shipping address, and issue a store credit. Internally, everyone knows store credits are for agents handling complaints, under a set amount. The generated card lists all three as skills. Six months later, a marketing team's agent finds the card and starts offering store credit as a goodwill gesture. Nothing was hacked. The card simply said it could.

Be particularly careful with skills that write. If a skill can change data, spend money or message a customer, consider whether it belongs on a card at all, or whether it should stay internal and be reached through a narrower read-only skill plus a human step. Our note on Step Functions workflows as agent tools covers the same split between steps an agent may run and steps a person approves.

Lock the door and test the failures

Decide who may call the agent before anyone does. Require authentication. Where both sides are services you control, mutual TLS is now supported from the remote client's default setup, which makes it easier to insist on. Keep a list of which callers may reach which skills, and log every call with the caller's identity.

Then try to break it. Cancel a task halfway through and confirm the work actually stops on your side, now that cancellation propagates. Force a failure and look at what the calling agent receives: a clean error event it can handle, or a vague success it will build on. Send a malformed request. Run your evaluation set several times rather than once, because an agent that passes once and fails the second run is telling you something.

The release has a reminder of why this matters. A breaking change to the skill script tool stops the model from passing a free-form shell command; the notes say plainly that this "closes a hole that let a prompt-injected model run arbitrary shell commands." When agents accept tasks from other agents, prompt injection is no longer a theoretical input. Every caller is a source of text you didn't write.

How the work moves

Before the first outside agent depends on yours

  1. Generate

    Run adk generate_agent_card to see what the agent claims today.

  2. Cut

    Remove skills you won't support. Rewrite descriptions in plain language.

  3. Lock

    Require authentication. Decide which callers may reach which skill.

  4. Break it

    Cancel a task mid-run, force a failure, send a malformed request. Watch what the caller sees.

  5. Evaluate

    Run the eval set several times, not once, and compare results.

  6. Publish

    Version the card, name an owner, and tell callers how changes will be announced.

Illustrative readiness sequence, not a client screenshot or measured result.

Version it and name an owner

Once other teams build against your card, changing it is an interface change. Version it. Name an owner who approves edits. Tell callers how changes will be announced and how long old versions keep working. If you regenerate the card from code on every deploy, make sure a human reads the diff before it goes out.

Start with one agent and one outside caller. Write the card together, test the failures together, and only then open it to a second team. Multi-agent systems are easier to keep honest when each agent has a job rather than a place on an org chart.

If you're designing agents that will call each other across teams or companies, and want the contracts, permissions and tests sorted before they go live, that's the work we do on AI applications and agents. Talk to TWIMCO.

Related work: Spin:Market

twimco.

We build alongside the people doing the work.
Bring us the problem you’re thinking about.

Related work

Spin:Market ↗︎