DEV Community: Obinna Aguwa

Building an AI-Powered Migration Pathways Agent with Go and the A2A Protocol

Obinna Aguwa — Mon, 03 Nov 2025 21:42:13 +0000

Planning to relocate internationally? The visa research process can be overwhelming, with countless pathways, varying costs, complex requirements, and constantly changing policies. I built an AI agent to solve this: a real-time migration advisor that analyzes your profile and returns the single best visa pathway, complete with costs, processing times, and actionable next steps.

In this post, I'll walk through how I built this agent using Google's Gemini LLM, the A2A (Agent-to-Agent) protocol, and deployed it on Heroku for seamless integration with platforms like Telex.im.

First of all, Telex is a collaboration workspace like Slack that allows developers to create AI Agents called AI Coworkers. The AI coworkers will work like a real human colleague. I might go in-depth in another article. For now, let's jump into the step-by-step process I took in building this migration pathways AI Agent.

What Does It Do?

The Migration Pathways Agent takes a simple natural language query like:

"I'm a software engineer from Nigeria wanting to move to Canada with a $10,000 budget"
And returns a structured response:

# Best Migration Option: Express Entry (Federal Skilled Worker)
This pathway is often the most straightforward option for skilled professionals seeking permanent residency in Canada, especially if they possess strong English or French skills, relevant work experience, and educational qualifications.
**Key Details:**
- Processing time: 6–12 months
- Cost: $2,300 - $3,000 (including application fees, language testing, ECA, and settlement funds)
- Success rate: Medium to High (dependent on CRS score relative to current cut-off scores)
- Main requirements: Minimum of one year of skilled work experience, Language proficiency (CLB 7 or higher in English or French), Educational Credential Assessment (ECA) for foreign education
Next step: Take an IELTS or CELPIP test and get your educational credentials assessed by a recognized organization (e.g., World Education Services - WES).

Architecture Overview

The system consists of three main components:

┌─────────────────────┐
│ CLIENT/USER │
└─────────┬───────────┘
 │ HTTP
┌─────────▼───────────┐
│ A2A PROTOCOL │
│ ┌─────────────────┐ │
│ │ Agent Card │ │
│ │ JSON-RPC 2.0 │ │
│ └─────────────────┘ │
└─────────┬───────────┘
 │
┌─────────▼───────────┐
│ MIGRATION AGENT │
│ ┌─────────────────┐ │
│ │ Query Parser │ │
│ │ Task Manager │ │
│ │ Gemini Client │ │
│ └─────────────────┘ │
└─────────────────────┘

1. A2A Protocol Layer

The A2A (Agent-to-Agent) protocol standardizes how AI agents communicate. I implemented two key endpoints:
Agent Card (GET /.well-known/agent.json):
Returns metadata about the agent's capabilities, supported methods, and configuration.
Planner Endpoint (POST /a2a/planner):
Accepts JSON-RPC 2.0 requests with methods:

message/send - Send a migration query
tasks/get - Retrieve task results
tasks/send - Legacy task submission ### 2. The Go Server I chose Go for its simplicity, performance, and excellent Heroku support. The server structure:

type MigrationAgent struct {
 gemini *GeminiClient
 tasks map[string]*Task
 mu sync.RWMutex
}

Key design decisions:

In-memory task storage: Simple map for task management.
Embedded agent card: Using Go's embed package to serve the agent.json
Flexible message parsing: Supports both Telex's format and standard A2A ### 3. Gemini Integration The magic happens in the Gemini client. Here's how I structured the prompt:

func (gc *GeminiClient) buildPrompt(userQuery, _, _ string, budget int) string {
 prompt := `You are a migration planning expert.
CRITICAL BEHAVIOR RULES:
- Never ask the user for additional information
- Extract profession, origin country, and destination country from the query
- If information is unclear, make reasonable assumptions
- Output exactly ONE best migration option
USER QUERY:
"` + userQuery + `"
`
 // … rest of prompt
}

Why this approach?
Initially, I tried parsing professions, countries, and origins with hardcoded maps. Bad idea. Users said "USA" but the agent suggested Canada because my parsing was too rigid.
The fix: Let Gemini extract ALL information from natural language. This supports any country, any profession, any language - no maintenance required.

Implementation Deep Dive

Step 1: Setting Up the Gemini Client

type GeminiClient struct {
 APIKey string
 BaseURL string
 Model string
}
func NewGeminiClient() *GeminiClient {
 return &GeminiClient{
 APIKey: os.Getenv("GEMINI_API_KEY"),
 BaseURL: "https://generativelanguage.googleapis.com/v1beta",
 Model: "gemini-2.0-flash-exp",
 }
}

I used gemini-2.0-flash-exp for its speed and strong reasoning capabilities - critical for extracting structured information from unstructured queries.

Step 2: Task Processing Flow

func (a *MigrationAgent) ProcessTask(taskID string, message Message) (*Task, error) {
 // 1. Create task with "working" state
 task := &Task{
 ID: taskID,
 Kind: "task",
 Status: TaskStatus{
 State: "working",
 Timestamp: time.Now().UTC().Format(time.RFC3339),
 },
 }
 
 // 2. Extract user query from message parts
 var userQuery string
 for _, part := range message.Parts {
 if part.Type == "text" {
 userQuery += part.Text + " "
 }
 }
 
 // 3. Query Gemini
 responseText, err := a.gemini.GetMigrationPathways(
 userQuery, "", "", profile.Budget,
 )
 
 // 4. Update task with results
 task.Status = TaskStatus{
 State: "completed",
 Message: &StatusMessage{
 Kind: "message",
 Role: "agent",
 Parts: []Part{{Kind: "text", Text: responseText}},
 MessageID: messageID,
 TaskID: taskID,
 },
 }
 
 return task, nil
}

Step 3: A2A Response Format

The A2A spec requires specific response structure:

{
 "jsonrpc": "2.0",
 "id": "task-id",
 "result": {
 "id": "task-id",
 "kind": "task",
 "status": {
 "state": "completed",
 "timestamp": "2025–11–03T…",
 "message": {
 "kind": "message",
 "role": "agent",
 "parts": [{"kind": "text", "text": "…"}],
 "messageId": "msg-id",
 "taskId": "task-id"
 }
 },
 "artifacts": […]
 }
}

This took iteration - initially I missed messageId and taskId in the status message, causing Telex integration to fail.

Deployment on Heroku

1. Procfile:

web: bin/server

2. Dynamic Port Binding:

port := os.Getenv("PORT")
if port == "" {
 port = "8080"
}
addr := ":" + port

3. Environment Variables:

heroku config:set GEMINI_API_KEY=your_key_here

4. Deploy:

git push heroku main

The Heroku Go buildpack automatically runs go install, compiles the binary to bin/server, and the Procfile starts it.

Key Learnings

1. Don't Over-Engineer Parsing

My first version had elaborate country/profession dictionaries. Gemini handles this better than any regex or dictionary lookup.

2. A2A Protocol Details Matter

Small spec violations (missing messageId, wrong JSON structure) break integrations. Test with actual A2A clients early.

3. Prompt Engineering Is Critical

The difference between "suggest migration options" and "provide THE SINGLE BEST option without asking questions" is massive. The second version eliminates back-and-forth.

4. LLM Temperature Matters

For structured output, low temperature (default) works better than high creativity settings.

Testing

I created .http files for VS Code REST Client:

POST {{host}}/a2a/planner
Content-Type: application/json
{
 "jsonrpc": "2.0",
 "method": "message/send",
 "params": {
 "message": {
 "role": "user",
 "parts": [{
 "type": "text",
 "text": "I am a nurse from Philippines wanting to move to UK"
 }]
 }
 },
 "id": 1
}

This made iteration fast - no need to rebuild integrations for every test.

Try It Yourself

Live API: https://migration-pathways-agent-ca4e1c945e86.herokuapp.com/a2a/planner
Agent Card: https://migration-pathways-agent-ca4e1c945e86.herokuapp.com/.well-known/agent.json
Example cURL:

curl -X POST https://migration-pathways-agent-ca4e1c945e86.herokuapp.com/a2a/planner \
 -H "Content-Type: application/json" \
 -d '{
 "jsonrpc": "2.0",
 "method": "message/send",
 "params": {
 "message": {
 "role": "user",
 "parts": [{
 "type": "text",
 "text": "I am a data scientist from India wanting to move to USA with $10000"
 }]
 }
 },
 "id": 1
 }'

Screenshot of the AI Agent on Telex

Conclusion

Building an AI agent isn't just about calling an LLM API - it's about:

Choosing the right protocol (A2A for interoperability)
Crafting precise prompts that eliminate ambiguity
Structuring responses for both humans and machines
Deploying reliably with proper error handling The Migration Pathways Agent demonstrates that with the right architecture, you can build practical, production-ready AI tools that solve real problems.

Repository: github.com/brainox/immigration-pathways-agent

Questions? Feedback? Hit me up on X @ObinnaAguwa or try the agent and let me know what visa pathway it suggests for you!

Getting Started with Pathway

Obinna Aguwa — Wed, 02 Apr 2025 13:42:36 +0000

If you work with real-time data and need a way to process it efficiently, Pathway might be the tool for you. It is designed to help developers handle data streams and build applications that react to changes instantly. This guide will walk you through how to get started and show you how to use some of its key features.

Installing Pathway

Before anything else, you need to install Pathway. It requires Python 3.10 or later, so make sure you have the right version installed. Open your terminal and run:

pip install pathway

That is all you need to do to get Pathway set up on your system.

Understanding How Pathway Works

Pathway is built around the idea of processing data as it arrives. Instead of handling data in batches, it continuously updates results as new information comes in. Here are some of the main things you will work with:

Tables – These hold your data, similar to a spreadsheet or a pandas dataframe.
Input Sources – These bring data into your Pathway application, such as CSV files, databases, or API streams.
Transformations – These let you filter, sort, and modify data to match your needs.
Output Destinations – These allow you to save processed data in formats like JSON or send it to another system.

With these basic ideas in mind, let’s go ahead and build something.

Creating a Simple Pathway Application

Here is a small example that reads data from a CSV file, filters it, and writes the results to another file.

Step 1: Import Pathway

Start by creating a Python file and adding this line:

import pathway as pw

Step 2: Read Data

Use an input connector to load data from a CSV file:

table = pw.io.csv.read("input.csv")

Step 3: Process the Data

Let’s say you only want rows where the value in the "amount" column is greater than 100. You can do that with:

filtered_table = table.filter(table.amount > 100)

Step 4: Write the Output

Now, save the filtered data to a JSON Lines file:

pw.io.jsonlines.write(filtered_table, "output.jsonl")

Step 5: Run the Program

Save your file and run it using Python. Pathway will process the data and save the filtered results.

What’s Next?

This is just a simple example, but Pathway can do much more. It supports handling data from live streams, integrating with machine learning models, and managing complex transformations. If you want to explore more, check out these resources:

Official Documentation – Learn about all the features in detail.
GitHub Repository – See the source code and examples.
Discord Community – Connect with other developers using Pathway.

Once you get comfortable with the basics, you can start experimenting with real-time data processing and more advanced use cases. Pathway makes it easier to build applications that react to data changes instantly, and with a bit of practice, you will be able to create powerful solutions for your projects.

What is DevRel and why are they important?

Obinna Aguwa — Mon, 17 Mar 2025 22:34:14 +0000

Not many people are familiar with the term "DevRel." To be honest, it is still relatively new since there aren’t many people with the job title of DevRel Engineer or Developer.
In this article, I will explain who a DevRel professional is and why they are important.

What is DevRel?

DevRel stands for Developer Relations. It is a field in tech that focuses on building authentic relationships with developers who use a particular technology. In my experience as a software developer, I tend to develop more interest in technology when I feel fully supported—such as having access to a community of developers who can answer my questions and provide resources to solve my problems. The people responsible for educating and supporting these developers are called DevRel professionals (or simply "DevRels").

It’s important to note that their role varies depending on a company’s needs. For example, in a tooling company like Microsoft, DevRels might focus on outreach, advocacy, and delivering tech demos or examples to developers. On the other hand, in a company like Google, DevRels might focus on evangelizing new tech offerings in AI.

The 3 Types of DevRel Roles

Community builder
Developer educator
Developer experience engineer

Community Builders focus on organizing events, hosting livestreams, managing Discord/Slack communities, and gathering feedback from users. They act as a bridge between the company and its developer audience.
Developer Educators create blogs, videos, and courses. They also speak at conferences and host workshops. Personally, this is the role that resonates most with me.
Developer Experience Engineers aim to make it easier for developers to use a product. They improve documentation, provide useful coding examples and demos, and streamline product integration to ensure a seamless experience.

Why Are DevRels Important?

They Enhance Brand Reputation.
A brand is shaped by how people perceive it, not necessarily by reality. DevRels are often closer to the developers who use a company’s tools because, more often than not, DevRels were developers themselves. They understand how developers think and can relate to their challenges. When developers find it easier to connect with a product, it invariably improves the company’s reputation.
They Improve Product Development.
DevRels gathers feedback from conferences, webinars, and direct interactions with developers. This feedback is invaluable for improving product features, fixing bugs, and identifying new business opportunities.
They Foster Community Building.
By providing platforms for developers to connect, collaborate, and share knowledge, DevRels helps create a more engaged and active ecosystem. Strong communities lead to stronger adoption of technologies and foster innovation.

Final Thoughts

DevRel professionals play a crucial role in bridging the gap between companies and their developer communities. Whether through education, community engagement, or improving the developer experience, they contribute significantly to the success of a product and the growth of its ecosystem.

As the tech industry continues to evolve, the importance of DevRel roles will only increase. If you’re passionate about both technology and people, this might just be the perfect career path for you!