CoolFace
Apppublic

MCP-1st-Birthday/agentic-economics

sourceHugging Faceapache-2.0updated 8mo agoView on Hugging Face
2likes
App README

An entry by the Covia team for the Hugging Face 1st Birthday hackathon.

Team:

Also available on GitHub: https://github.com/covia-ai/agentic-economics-hackathon

Vision

Agents shouldn’t just answer questions – they should coordinate, contract, and transact.

Our goal is simple: show a glimpse of what agentic economies looks like when you move beyond glue code and brittle workflows, and treat agents as economic actors operating on top of a shared grid.

This project is our exploration of what happens when you give AI agents:

  • —a shared orchestration grid,
  • —a real system of record,
  • —and the ability to form and execute economic contracts.

For the MCP 1st Birthday Hackathon – Track 1, we use the Covia Federated Orchestration Grid together with MCP, Anthropic Claude and Cursor to let agents:

  • —negotiate terms,
  • —draft and validate economic contracts,
  • —and execute them end-to-end across tools and providers.

Demo

Covia Team Hugging Face demo link here:

  • —link to YouTube demo - https://youtu.be/7KkT8efTv1s
  • —link to HuggingFace space - https://huggingface.co/spaces/MCP-1st-Birthday/agentic-economics
  • —Social Media post - https://x.com/mikera/status/1995277731609653316

Agentic Economic Contracting with Covia.ai (MCP Hackathon – Track 1)

Agents shouldn’t just answer questions – they should coordinate, contract, and transact.

This project explores what becomes possible when you give AI agents:

  • —a shared orchestration grid,
  • —verified, governed tool access via MCP,
  • —multi-provider cognitive capabilities (Claude, OpenAI, Gemini, Cursor),
  • —a powerful DLT for economic assets and smart contracts (Convex),
  • —and a real, append-only system of record

For the MCP 1st Birthday Hackathon (Track 1), we built a prototype where agents negotiate, draft, validate, and execute economic contracts — end-to-end — across Anthropic, OpenAI, Manus, and the Covia Grid.

This is our first glimpse of agentic economics: agents acting as economic participants, not chatbots.

Project Overview

This project demonstrates an agentic economic coordination system built using:

  • —MCP (Model Context Protocol) for unified tool/model interoperability
  • —Anthropic Claude for negotiation + reasoning
  • —OpenAI tools for structured execution
  • —Google Gemini (optional) for multimodal analysis
  • —Covia.ai Federated Orchestration Grid for shared memory, contract state machines, and a governed system of record

What the agents actually do

Agents:

  1. 1.Propose economic terms
  2. 2.Negotiate until agreement
  3. 3.Draft a structured JSON contract
  4. 4.Validate through Claude/Cusror + MCP
  5. 5.Execute actions using Claude tools
  6. 6.Commit all state to the Covia Grid
  7. 7.Produce an auditable, append-only ledger

This is a proof-of-concept for multi-agent, multi-LLM economic coordination.

Problem Statement: Why We Built This

Today’s agent frameworks break when you attempt real multi-agent coordination:

  • —no shared memory
  • —no shared system of record
  • —no contract/state model
  • —no cross-LLM cooperation
  • —brittle tool chains
  • —hidden execution context

If agents are ever going to participate in commerce, operations, logistics, payments, or negotiations, they need:

  • —verifiable contracts
  • —cross-provider cognition
  • —tool-level governance
  • —state synchronisation
  • —append-only auditability

This project demonstrates the earliest version of that future: agents as economic actors, not isolated chatbots.

What’s Unique About Our Approach

Most agent demos rely on:

  • —prompt wrappers
  • —LangGraph spaghetti
  • —static workflows
  • —single-LLM dependence
  • —hidden state

Our approach is different:

  • —Multi-provider cognition (Claude, ChatGPT, Cursor, Manus, Gemini etc.)
  • —MCP as a flexible protocol for accessing economic systems
  • —Covia Grid as a shared execution + memory layer
  • —Full end-to-end system of record
  • —Economic contract objects (not JSON hacks)

This combination enables negotiation, validation, execution, and reconciliation across agents — something no existing framework provides.

How We Used MCP (Track 1 Requirements)

This submission is built specifically for Track 1: Build with MCP.

We use MCP in three ways:

A. MCP as the universal transport layer

MCP lets Claude, OpenAI, Gemini, and Manus communicate through:

  • —a shared message schema
  • —unified tool calling
  • —model-agnostic interoperability
  • —consistent tool validation responses

This removes 90% of typical agent-framework brittleness.

B. MCP + Claude for safe tool execution

Claude is our MCP server providing:

  • —contract validation tools
  • —economic rule enforcement
  • —secure sandboxed execution
  • —deterministic error handling

All tool calls go through MCP → Claude/Cursor → Covia for recording.

C. MCP as the foundation of agent-to-agent coordination

Agents provide tool outputs to each other via MCP-triggered events, including:

  • —contract drafts
  • —negotiation summaries
  • —validation results
  • —execution confirmations

MCP ensures ensure all in interactions have a consistent, verifiable structure and are usable for a wide range of agentic tools.

Usage

Helpful tools and links

The space running the MCP server is:

https://mcp-1st-birthday-agentic-economics.hf.space

You can explore the Covia Grid, look at job history etc. with the Covia App - connect to the venue at https://mcp-1st-birthday-agentic-economics.hf.space to browse jobs, assets and operations.

Access to the Convex test network used in the demo is also available via a Hugging Face Space which provides an explorer interface, REST API endpoints and also has its own MCP tools:

https://mikera1337-convex-testnet.hf.space

Components Included in This Submission

This repo includes:

  • —Dockerfile → Dockerfile for demo space: https://huggingface.co/spaces/MCP-1st-Birthday/agentic-economics
  • —README.md → submission documentation (this file)
  • —config.json → Config file for the Covia grid venue
  • —actors - Convex Lisp actor code used for communication / contract making
  • —prompts - Example prompts for doing different kings of transactions

The demo has dependencies on:

  • —Convex - Convex testnet code, used to run a separate Space for the shared global DLT layer at https://huggingface.co/spaces/mikera1337/convex-testnet
  • —Covia Venue - Grid venue code used for the grid server

Social Post (Public Announcement)

As part of our submission, we shared a social post explaining the concept and inspiration behind our Track 1 project.

Public Post: Post by Mike

This post introduces the idea of agents negotiating and executing economic contracts using MCP + Claude + Cursor + Covia Grid, and provides context for our submission.

Acknowledgements

Thanks to:

  • —HuggingFace and Partners for hosting the MCP hackathon
  • —The Anthropic team for providing the MCP server
  • —Anthropic, OpenAI, and Google for their APIs
  • —The MCP community for building a shared foundation

License

Apache 2.0 License.

See LICENSE.txt file in this repo.