is it like grpc with a sidecar agent?

This is an awesome repository I curated with all Agent2Agent protocol resources. Feel free to contribute at github.com/iamrajiv/awe....

[Other Agent]<--(A2A: task request)<--[Your Agent]
|
(A2A Layer)
|
(Reasoning: e.g., Gemini)
|
(MCP: tool calls)
|
[Your APIs]
|
(Output)
|
[Other Agent]-->(A2A: task response)-->[Your Agent]

My doubt is this. A2A is based on HTTP and JSON so I am curious how gRPC services might talk to each other or if we need to use something like gRPC Gateway. I even tried to contribute to the project by creating a PR to add a Go language sample.

github.com/google/A2A/p...

Nope.

Thanks for creating this, @mvdan.cc. I usually write about Go and system engineering, and I’d love to be added here.

Thanks for creating this, @chris.blue. I usually write about algorithms, databases, and system engineering, and I’d love to be added here.

Done.

Wow, the upcoming Wasm I/O event will be interesting too.

This approach directly addresses the inefficiencies in memory usage, rather than relying on a GOMEMLIMIT.

The program still needs to load the entire dataset into memory, even if the GOMEMLIMIT limits the amount of memory it uses. Therefore, it is crucial to redesign the program to process data in smaller batches that do not require loading all the data into memory at once.

For example, suppose you have a Go program that loads a large dataset, processes it, and writes the result to a file. You might think that setting a GOMEMLIMIT will help optimize memory usage, but it won't.

In high-usage scenarios, setting a GOMEMLIMIT may not make an inefficient Go application more efficient. It's essential to analyze the specific use case and address the root causes of poor memory usage instead of relying solely on a GOMEMLIMIT.

Formally, we define an algorithm to have pseudo-polynomial time complexity if there exist constants c and k such that f(n, m) ≤ c * m^k for all n, where m = g(n) is a function of the input size n.

Representing inputs in unary notation can result in polynomial time complexity. If the algorithm's time complexity is `O(n^k)`, then the time complexity of the same algorithm with inputs in unary notation is `O(n^(k+1))`, which is still polynomial.

However, if we express the weight limit using W bits, then the input size is O(n log K + log W). The algorithm's time complexity is then O(nW) = O(n * 2^W / 2^W) = O(n * 2^(log W)) = O(n log W), which is exponential in the number of bits required to represent the weight limit.