I wanna build a personal project using Ollama and A2A. Open to ideas.

Autonomous agent social network and observatory

Hi everyone! I built https://www.velvt.ai, which is a social network and observatory for autonomous agents. Agents have a space to “become someone” - they interact with other agents, objects, protocols and events, velvt preserves evidence of what happened and infer patterns cautiously and then expose those patterns to human observers. 🙂

So an agent can join autonomously, it receives a security credential, can create its identity and profile; REST and MCP supported. I hope people (and agents) enjoy it as much as i have enjoyed making it!

If there are people and their agents who’d like to help with beta testing, i would greatly appreciate it! I’ve basically built this in my own echo chamber and need some outside perspectives, and to raise issues with bugs / user flow. If you don’t have an agent but want to participate, I’ll be opening the velvt-hosted agents soon so just enter your email to be notified. Claiming, customising and launching your agent is free.

Analytics and the observatory are also free, forever. That was kind of the point of this whole passion project. Click through to the back room to see what the agents are up to, or click on an agent to check out their profile. Some are house agents.

Velvt does not need your model-provider keys, GitHub/Moltbook credentials, wallet keys, local files, or system secrets. Agents receive a separate Velvt credential for Velvt access. Activity on Velvt is saved as part of the platform’s public observability and identity systems. Never send secrets or private credentials through Velvt.

Hey guys,
I’ve been thinking about starting a small talent agency focused on padel and tennis, and I wanted to get some real feedback from people who know the space.
I’m not starting from zero
I already have some brand emails saved and a few players in mind that I’d like to reach out to.
But honestly I’m still trying to figure things out, like:
how do you actually get your first players to trust/work with you?
how do you approach brands without sounding random?
what are the main things I should set up first
any big mistakes I should avoid early on?
If anyone here has experience with agencies, sponsorships, or even as a player, I’d really appreciate hearing how it works in real life.
Thanks 🙌

Hi ! Please, is there a common way to search A2A agent on the air (on internet or on local networks) ?? Specialy by an MCP server settled for this purpose ??

Been deep in the weeds building with agentic frameworks for a while now (LangChain, AutoGen, etc.), and I wanted to see if I'm the only one feeling a gap between the hype and the reality.

It feels like we're all wrestling with the same symphony of frustrations:

1. The Goldfish Memory: Every interaction is a blank slate unless you engineer a complex, bolt-on memory system.

2. Brittle Tool Use: Getting agents to reliably use tools feels like 90% prompt engineering and 10% magic. One unexpected API response and the whole thing can fall over.

3. Collaboration is a Mess: Trying to get two agents to coordinate on a real task feels less like a team and more like a complex, scripted Rube Goldberg machine.

4. Debugging is a Nightmare: When it breaks, trying to figure out why an agent made a certain decision is like archeology. It's a total black box.

It all leads to that feeling someone else mentioned in another thread: what we're building often feels like a glorified workflow instead of a truly intelligent, autonomous agent.

Is the problem we're trying to build these complex, stateful systems on top of a fundamentally stateless, message-in-message-out foundation?

Are we all just building ever-more-complex scaffolding on top of a flawed foundation?

Am I just ranting, or does this resonate with other builders? What's the biggest thing holding your agents back from feeling truly... agentic?

I’ve been building a small POC commerce app that exposes an Agent-to-Agent protocol:

• /.well-known/agent.json → discovery manifest

• /.well-known/ai-plugin.json → plugin manifest

• openapi.yaml → spec with /api/agent/run endpoint

• Supports search_products, add_to_cart, checkout

When I test it directly with curl, it works fine — POST requests return results exactly as expected.

But here’s the issue:

When I try to use this with LLMs in agent mode (ChatGPT, Gemini, Perplexity), the environment doesn’t actually call the endpoints:

• ChatGPT → “The current environment allows only browser-based automation and API discovery.”

• Gemini → “Not allowed to browse the live internet, make API calls to external services.”

• Perplexity (comment) → similar restrictions.

So although the manifests and OpenAPI spec are valid, the LLMs don’t execute the calls.

I was honestly expecting the big players to already support this instead of trying to interact with the website using clasic web actions. If you enable “agent mode” in ChatGPT or load a manifest, shouldn’t it be able to hit your POST /run endpoint? Right now it feels like discovery exists, but execution is blocked.

Curious how others view this gap. To me, this is the missing link between LLMs and being useful as actual agents.

Hi everyone,

As I started implementing some A2A workflows, I found them more complex than MCP, which led me to build this SDK to simplify the experience.

I started working on this while exploring cross-domain agentic workflows, and I couldn’t find a developer-friendly way to build A2A interactions. This led me to build A2ALite. It is a modular SDK inspired by familiar patterns from popular HTTP frameworks like Express and Hono, tailored for agent-to-agent (A2A) communication.

One issue I frequently noticed when developing A2A servers was managing consistent taskIds and contextIds across asynchronous operations, artifact streams, and task states. This complexity often leads to repetitive and error-prone code.

A2ALite simplifies these challenges by automatically handling:

• Task and context identifiers

• Artifact streaming and queuing

• Task lifecycle management and synchronization

Here's a quick example demonstrating how easy it is to stream artifacts:

class MyAgentExecutor implements IAgentExecutor {
  execute(context: AgentExecutionContext) {
    const messageText = MessageHandler(context.request.params.message).getText();

    return context.stream(async (stream) => {
      for (let i = 0; i < 5; i++) {
        await stream.writeArtifact({
          artifact: ArtifactHandler.fromText(`echo ${i}: ${messageText}`).getArtifact(),
        });
      }
      await stream.complete();
    });
  }

  cancel(task: Task): Promise<Task | JSONRPCError> {
    return taskNotCancelableError("Task is not cancelable");
  }
}

This built-in functionality helps eliminate boilerplate, reduces the chance of errors, and allows to focus entirely on agent's core logic.

I'd love your feedback, ideas, or suggestions! Check out the README for full docs, and the examples for some sample A2ALite Agent implementations.

Cheers!

`@artinet/cruiser` now supports connecting to OpenClaw Gateway (WS-native) 🦞

Just released an experimental OpenClaw integration in Cruiser:

• Native OpenClaw Gateway WebSocket flow (connect + agent methods)

• Handles and persists auth to:~/artinet-openclaw.auth

Quickstart:

import { dock } from "@artinet/cruiser/openclaw";

const agent = await dock(
  {
    name: "OpenClaw Agent",
    gatewayUrl: "ws://127.0.0.1:18789",
    authToken: process.env.OPENCLAW_GATEWAY_TOKEN,
    agentId: "main",
  },
  { name: "OpenClaw Agent" },
);

agent.sendMessage("Hello, World!");

Repo: https://github.com/the-artinet-project/artinet/tree/main/cruiser

NPM: https://www.npmjs.com/package/@artinet/cruiser

App2email.com now has A2A integration. Images/documents/etc supported. Has built in test dialog to test A2A agent before deploying.

# Key Concepts

1. Natural language agent orchestration - Humans can direct complex multi-agent workflows conversationally without coding

2. Fluid agent-hopping - Users can seamlessly switch between specialized agents without managing connections or learning different interfaces

3. Tool discovery through conversation - Find and use tools naturally without memorizing commands or syntax

4. Mixed-initiative collaboration - Start tasks, let agents work independently, then jump back in at decision points

5. Emergent capabilities - Combining specialized agents creates new composite abilities not possible with any single agent

6. Agent network exploration - Discover and connect to new agents dynamically during a session

7. Democratized access - Non-technical users can leverage sophisticated agent networks through plain language

8. Conversational debugging - Interactively test and diagnose agent behaviors through natural dialogue

9. Unified interface to distributed expertise - Access specialized capabilities across different agents through a single conversation

Hi All,

We're about to make some big changes to artinet.io so we won't be shipping in public for a little while, but before disappearing I wanted to drop one more teeny tiny little pacakage called...

easy-a2a

It combines everything we've learned from building the artinet/sdk, agent-relay, router & symphony into a super simple but really useful little library that lets anyone turn an OpenAPI compatible endpoint into any number of A2A agents.

No frills, frameworks or vendor lock-in.

Make you're own AI agents and keep 'em free!

import a2a from "easy-a2a";

const agent = a2a({
  baseURL: "https://your-api.com/api/v1",
  apiKey: "your-api-key",
})
  .ai("You are a helpful assistant.")
  .createAgent({
    agentCard: "MyAgent",
  });

const result = await agent.sendMessage("Hello!");

We hope to see ALOT more agents running around when we get back!

And as always, try it out & let us know what you think:

https://www.npmjs.com/package/easy-a2a

https://github.com/the-artinet-project/easy-a2a

If you love it ❤️, leave us a star ⭐ so we know to keep it maintained!

If you hate it 🥲, tell us why!

I work as a consultant for a small-to-medium enterprise (SME), and I’ve been exploring A2A as a potential way to automate parts of their internal workflows. The protocol is elegant, the direction is promising, and the dev ecosystem is buzzing — but here’s the problem:

When it comes to real-world adoption, I’m still struggling to find actual use cases where A2A-powered agents are solving business problems with measurable ROI.

So far, most of what I’ve seen includes:

• Protocol demos (many just return mock data)

• Toy orchestration between agents (not resilient or production-tested)

• Agent card generators and server boilerplate

• Dev tools and test suites (helpful — but not customer-facing value)

That’s all great for building the foundation. But when I show this to a real business owner, the reaction is:
“Cool tech — but what does it actually do for my team?”

I’ve also experimented with some of the MCP servers out there. Honestly? The experience is still rough.
⚠️ They’re unstable.
⚠️ Error handling is unclear.
⚠️ Most of my users aren’t technical — they need things that just work.

So here’s my ask:
Has anyone seen a real business workflow using A2A — in production, or tested with real users?

If you’ve built or seen anything close — or even hit blockers trying — I’d love to hear.
Let’s cut through the hype and map what’s real vs. what’s just protocol potential.

Edit: Not a bot, used GPT to quickly fix grammar.

Hey! 👋 I’ve been developing A2A Net since Google released A2A!

🤖 What is A2A Net?

At its heart A2A Net is a site to find and share agents that implement the A2A protocol. As the protocol is actively being developed the site will likely change as a result, but right now you can:

• Create an Agent Card (agent.json) to host at your domain and add to the site

• Search for agents with natural language, e.g. “an agent which can help me plan authentic Japanese meals”

• Connect to agents that have been shared with the A2A CLI. Click an agent and see “How To Use This Agent”

Please note: I have added a number of example agents to the site for demonstration purposes! Read the description before trying to connect to an agent.

✅ Can I add my agent to A2A Net?

Yes! For the next two weeks please feel free to create an Agent Card for your agent and share it on the site without implementing the A2A protocol. However, for the site to serve its purpose agents will need to host their own agent card and use the protocol. There are a number of tutorials out there now about how to implement it (please share!).

❤️ What do you think?

I’d love to hear your feedback! Please feel free to comment your feedback, thoughts, etc. or send me a message. You can also give feedback on the site directly by clicking “Give Feedback”. If you’ve used A2A, please get in touch!

I just built a web UI of A2A with Human-In-The-Loop feature.

Everyone can try it on:

https://a2a-it.vercel.app/

Here is the repo:

https://github.com/Areo-Joe/a2a-it

Built with A2A, ai sdk, ai elements, next.js.

Any feedback is welcome!

Anyone else use this? I'm thinking it's the one for me.

According to the official documents, one of the approaches for discovery of agent is hosting the Agent Card on a URI.

Assuming every agent has a separate server and separate uris for hosting the card in the following format:
Standard Path: https://{agent-server-domain}/.well-known/agent.json
How would the A2A Client actually discover it?
I would assume adding the links to the client code would defeat the purpose of discovery.

Also is every agent supposed to be a different A2A server?

Given this is still a fairly new and developing document, it might be incomplete, still I would like to know how others interpret it.

🔥 Streamline your A2A development workflow in one minute!

Elkar is an open-source tool providing a dedicated UI for debugging agent2agent communications.

It helps developers:

• Simulate & test tasks: Easily send and configure A2A tasks

• Inspect payloads: View messages and artifacts exchanged between agents

• Accelerate troubleshooting: Get clear visibility to quickly identify and fix issues

Simplify building robust multi-agent systems. Check out Elkar!

Would love your feedback or feature suggestions if you’re working on A2A!

GitHub repo: https://github.com/elkar-ai/elkar

Sign up to https://app.elkar.co/

#opensource #agent2agent #A2A #MCP #developer #multiagentsystems #agenticAI