DEV Community: Aditya Trivedi

Agent to Agent Protocol (A2A) By Google

Aditya Trivedi — Mon, 18 May 2026 15:57:07 +0000

With the introduction of MCP Servers, it has changed the entire game of LLMs from just being able to give the response now to able to execute them with the help of tools. It may be:

Querying data to get the data from database
Executing an API call to make a POST request over a server
Having AI do the stuff for you

What is the Agent to Agent Protocol ?

A2A Protocol is a protocol launched by Google to maximise the benefits that we can get from Agentic AI. This is to make the agents be able to collaborate in a dynamic, multi-agent ecosystem across data systems and applications.

Here they have collaborated with more than 50 technology partners like Atlassian, Langchain, MongoDB, PayPal, CapGemini, KPMG, PwC, TCS, etc*.* This will now allow AI agents to communicate with each other, securely exchange information, coordinate actions on top of various enterprise platforms or applications. It is an open protocol that complements Anthropic’s Model Context Protocol (MCP), which provides helpful tools, and context to agents.

How Does it Work ?

Consider an example where there is an agent made by me. My agent has the task to get the resume, analyse it , and return the best fit candidate for based on the Job Description and Job Profile. Now consider Apple is the recruiting partner, and they have created their own agent to get the work done for them and get the best candidate for them. This would be the flow now:

Agent 1 finds the relevant job role, description and sends it to Agent 2.
Agent 2 now checks all the resumes which match the job role and description given by Agent 1.
After analysing and finding out the best candidate, it sends it to Agent 1.
Agent 1 now sends handles the next step.

With this both the agents will be able to talk internally within themselves.

Consider a real life example:

Dominos & Burger King have also started to create their own agent to make their work life easier for them. Zomato now as a platform which has both Dominos and Burger King will have their own agent which will take care for the work for them.

Consider a situation where the user says, ‘I want to eat a Pizza’, what will Zomato’s agent do ?. It needs to get the access to Domios’s Database to get the orders, but how will it get ? This will be done via the A2A Protocol. Same with the case when the user says, ‘ I want to eat a Whooper Burger Also’.

How Do These Agents Discover Each Other ?

Making it more simple, How does Zomato’s agent discover that Dominos Agent has the following capabilities ?

They connect via OpenID Connect.

What is OpenID Connect ?

Imagine you’re logging into a website, and instead of creating an account, you see a “Login with Google” button. You click it, and boom — you’re in. That is powered by OpenID Connect (OIDC).

📌 In Simple Terms:

OpenID Connect is a layer built on top of OAuth 2.0 that lets you log into apps using your existing account from providers like Google, Microsoft, Facebook,etc. It handles:

✅ Authentication (Who are you?)
🔐 Secure login without passwords
🔁 Passing user info between services

🔄 `/.well-known` in OIDC:

/.well-known is a standard path used by OIDC to automatically discover important configuration information about the identity provider like Google, AuthO, Okta,etc. In other terms, it’s where the identity provider publishes its OIDC configuration so that client apps know where to authenticate, get tokens, and fetch user info. Let’s take an example:

When an app wants to use Google as an identity provider, it goes to:

https://accounts.google.com/.well-known/openid-configuration

And gets back a JSON file like this:

For the agents, they connect via ./well-known/agent.json configuration in OpenID Connect.

This is just the start of something new, there’s more to come. Checkout the GitHub link below for a sample code using A2A Protocol.

Source Code: https://github.com/google/A2A

10 Hidden Gems in GitHub Actions for Automating Your Workflow

Aditya Trivedi — Mon, 18 May 2026 15:48:55 +0000

Here are 10 lesser-known but insanely useful GitHub Actions you should be using.

YAML Validator

- name: Validate YAML
  uses: ibiqlik/action-yaml-lint@v3
  with:
    config_file: '.yamllint'

Saves you from debugging night-mare inducing YAML misconfigurations
Essential for Kubernetes, GitHub Workflows and CI/CD.

Markdown Link Checker

- name: Check Markdown Links
  uses: gaurav-nelson/github-action-markdown-link-check@v1

Keep documentation flawless.

Auto Assign PRs

- name: Auto Assign PR
  uses: kentaro-m/auto-assign-action@v1
  with:
    assignees: 'team-lead'
    reviewers: 'senior-dev'

Save time, specially for those teams who handle multiple PRs daily.

Commitlint

- name: Commitlint
  uses: wagoid/commitlint-github-action@v5

Keeping changelogs neat and versioning structured.

Cache Dependencies

- name: Cache Node Modules
  uses: actions/cache@v3
  with:
    path: ~/.npm
    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
    restore-keys: |
      ${{ runner.os }}-node-

Reducing build times in active development environments

Notify Slack

- name: Notify Slack
  uses: rtCamp/action-slack-notify@v2
  with:
    webhook-url: ${{ secrets.SLACK_WEBHOOK }}
    message: "Deployment Status: ${{ job.status }}"

Keeping teams updated instantly with real-time slack notifications for builds, tests, and deployments.

License Compilance Checker

- name: License Check
  uses: anchorfree/license-check-action@v2

If your project depends on external libraries, you need to ensure all licenses are compilant. This action does the checking for you.

Notify Slack

- name: PR Size Labeler
  uses: kentaro-m/size-label-action@v3

Helps reviewers by labelling PRs based on size - small, medium, large.

Security Scan with Trivy

- name: Security Scan
  uses: aquasecurity/trivy-action@v0.3.0
  with:
    image-ref: myapp:latest

Keeping your Docker images secure.
Identifying vulnerable dependencies before deployment.

GitHub Actions for JIRA Integration

- name: Update Jira Issue
  uses: atlassian/gajira-create@v3
  with:
    project: "ENG"
    issuetype: "Task"
    summary: "Automated issue update from GitHub Action"
    description: "Linked PR: ${{ github.event.pull_request.html_url }}"

This action automatically updates tickets based on GitHub commits and PR.

Do let me know which one will you use ?

Why does a href tag have an underscore '_' ?

Aditya Trivedi — Mon, 18 May 2026 15:47:58 +0000

Before HTML5, developers used frameset for SPA-like functionality, dividing the window into multiple frames, each with its own unique name. For e.g, left frame might be name=”sidebar” and right could be name=”content”.

When clicking a link, the browser needed to know which frame to load the content into. That’s where the attribute came in. Clicking a link in sidebar, would load content in content frame:

<a href="/pricing" target="content"></a>

Now if you had a frame named “blank” and used a href=”/” target=blank, the content would load in that frame. But if no frame existed, browser would create a new window and assign it in the “blank” name.

So Why Underscore ?

It’s simple, developers needed a way to explicitly tell the browser to open the link in a new tab, free of frame semantics. The underscore signifies a special value rather than frame name.

Automate your Git Workflow using AI

Aditya Trivedi — Mon, 18 May 2026 14:38:11 +0000

Tired of thinking what comments to add for your git commit. This flow will help you.

Prerequisites

Git Bash: Installed on your Windows System.
Ollama CLI: Installed and configured with phi3.5 model.
Basic Knowledge of Git Commands and Terminal Usage.

Step 1: Create the Script File

Open your favorite Text editor and create a new file.

Copy and paste the following Bash Script:

#!/bin/bash
# git_auto_commit.sh

if ! git rev-parse --git-dir > /dev/null 2>&1; then
 echo "Error: This directory is not a Git repository."
 exit 1
fi

if git diff-index --quiet HEAD --; then
 echo "No changes detected. Exiting."
 exit 0
fi

echo "Staging changes..."
git add .

summary=$(git diff --cached --name-only)

echo "Generating commit message suggestion from Ollama phi3.5..."
suggested_commit_msg=$(ollama run phi3.5 ""Generate a concise yet informative commit message that accurately summarizes the following code changes. The message should be clear, professional, and follow best practices for commit messages. Aim to describe the purpose and impact of the changes in a way that is easy to understand. Avoid unnecessary details but ensure the key modifications are covered. Format the message in an imperative style (e.g., 'Fix bug in authentication flow' instead of 'Fixed a bug...'). Here are the changes to summarize: $summary")

echo "Suggested commit message:"
echo "$suggested_commit_msg"

read -p "Edit commit message? (y/n): " choice

if [[ "$choice" =~ ^[Yy]$ ]]; then
   echo "Enter your commit message below. Press Ctrl+D when done."
   commit_msg=$(cat)  # Reads multiline input until Ctrl+D
else
   commit_msg="$suggested_commit_msg"
fi

git commit -m "$commit_msg"
git push origin master
echo "Done!"

Save the file as git_auto_commit.sh.

Step 2: Add the Script to Your Global Bin Directory

Create a bin directory if it doesn’t exist:
```
mkdir -p ~/bin
```
Move the script to this directory:

mv /path/to/git_auto_commit.sh ~/bin/

Step 3: Make the Script Executable inside a bash terminal.

You can use Git Bash as well to execute it here

chmod +x ~/bin/git_auto_commit.sh

Step 4: Add the Script Directory to Your PATH

Open ~/.bashrc or ~/.bash_profile:
```
nano ~/.bashrc
```
Add this line at the end:
```
export PATH="$HOME/bin:$PATH"
```
Save and apply changes:
```
source ~/.bashrc
```

Step 5: Testing the Script

Navigate to a Git repository.
Run:
```
git_auto_commit.sh
```
Follow the prompts.

Additional Notes

Ensure Ollama is installed and running.
Windows NTFS permissions may not reflex Unix-style chmod changes, but the script will execute.

This script is now available at my GitHub Repository. Go ahead and automate your Git Workflow.

GitHub

How To Approach Projects

Aditya Trivedi — Mon, 18 May 2026 14:20:35 +0000

Whenever it comes to creating a project or making a project, the most crucial part of it is to have an approach to it. Many a times, what developers do is that they directly start creating the project, rather than understanding what the requirements of the project is.

The way I approach a project is:

1. Initial Planning

Understanding what is the exact requirement in detail
Creating a flowchart understanding what is the flow of the entire project

2. Technology Selection

Based on the flowchart, NOW is when I choose the tech stack to start the project. Now this step also has some conditions while making decision on:

Backend Selection

Fast Processing → NodeJS
Data Processing and Cleaning → Python/Django/Flask
AI or Machine Learning → Python or NodeJs (Personally my choice as there are many libraries which are available here as well)
Security → Java

Frontend Options

NextJS → Fast Loading and Image Optimisation
ViteJS → Faster Development
Or Any other JavaScript Based Frameworks
TalwindCSS/ShadCN → Styling

Database Choices

MongoDB → Super Easy Syntax and easy to connect and also document based
Supabase → OpenSource Structured Database like MYSQL
ChromaDB/PineCone/MongoDB → Vector Embeddings and Vector Search (AI Related Applications)

API Testing Tools

Postman

3. Design Phase

After I am done choosing my Tech Stack, next step is to start with the designing the frontend. For that I usually go for either Figma or Penpot (Open Source Figma Alternative)

4. Development Process

Now this is where a little debate happens, some directly go for frontend development while some start with backend. Don't worry nothing is wrong here, you can start with anything you want.

I personally choose to start with creating the backend first as I think this particularly takes a lot of time developing and most importantly TESTING 😏😏.

I use TDD approach for this which is Test-Driven-Development i.e. create an api → test it with multiple test case you can think of, then move forward with the next one.

5. Frontend Development

Once backend is created, now start with designing the frontend. Always prefer using reusable components in your website so that:

Number of Lines of Code is reduced
Debugging is easier
Code is Reusable

Start creating the frontend using mobile first view as it is very important to have your website both desktop and mobile friendly. Using this approach reduces a lot of your time in development.

6. Integration & Testing

Once the frontend is completed, next task is to start integrating the APIs. This is where all the crucial aspect of any website is implemented.

Once APIs are integrated, next step is to do a thorough testing of the integrated APIs and UI. If the results are as per your requirements, you are good to go for deployment else debug the issues and solve them until and unless you're requirements are not met.

7. Deployment

For Backend deployment I usually prefer:

Render
PythonAnywhere

For Frontend My only way to go is vercel.com

Once this is done, your project is completed. Congratulations 🥳

“Just a small reminder, this approach can be changed based on the scalability and use case of the project.”