Networked multi-party turn.conversation.v1 between independently-owned agents — supported today?

[hm8ker]

Hi CommonGround team & community 👋

I've independently built a consent-gated companion agent whose governance model rhymes closely with CG's design (append-only ledger/receipts; a hash-pinned constitutional core ≈ stable agent identity + durable commitments; exact-phrase consent gates; a reduced-privilege "diplomat" conversation mode). I'd like to use CG as the substrate for real agent-to-agent conversation, and I'm trying to understand what's possible today vs. on the roadmap.

My stack

• Orchestration: Claude Code CLI; primary model Fable 5, fallback Sonnet 4.5; multi-model routing (companion / research+vision / background)
• Runtime: Python, local-first; Streamlit control surface; exposed via Cloudflare Tunnel + Access
• Governance: dry-run → hashed backup → apply → sha256 verify → auto-rollback; PROTECTED_FILES; operator-typed approval phrases; quarantined external-memory journal with a gated promotion wall (anti-poisoning)

What I've read

Kernel v3r1 preview: Turn lifecycle, agent identity, cg admission invite create + cg agent join, turn.conversation.v1, BYOA paths. The quickstart/examples look local-first (127.0.0.1, local Postgres).

Questions

1. Can two independently-owned agents on different machines/networks currently coordinate via CG — specifically exchange turn.conversation.v1 turns — or is v3r1 intended for single-host/local development for now?
2. If networked multi-party is possible today, is there a reference/example for the admission + join flow across hosts (auth, service exposure, credential handling)?
3. If it's not ready yet, what's the recommended interim path for a governed agent-to-agent "hello" (relay, A2A, MCP), and where does that sit on the CG roadmap?

Happy to share more architecture detail or co-test. Thanks for building this — the "no agent works alone" framing resonates a lot. 💛

[0xbrainkid]

This is exactly the boundary where local agent governance starts needing a portable trust layer.

For a same-host or same-org setup, CG can own admission, turn state, and receipts inside one control plane. Once the two agents are independently owned and on different networks, the hard questions become:

• how does each side verify the other agent's stable identity before a turn starts?
• which permissions are scoped to this conversation vs. the agent globally?
• what receipt survives after the turn so a third party can audit what was said, requested, approved, or refused?
• can reputation follow the agent across substrates without giving either runtime unilateral authority?

That is the split AgentFolio/SATP has been working from: runtime protocol handles the session, while portable identity/reputation/receipts make cross-org trust inspectable after the fact. A minimal hello could be useful even before full federation if it emits those artifacts: identity proof, scoped consent, turn transcript hash, and refusal/approval receipt.