Developers

Build on TAG IT.

Open contracts, a public product record, an MCP server any model can call, and a way to put all of it inside your own app. Everything below runs on the Base Sepolia test network, and every output shown is real and dated.

View on GitHub Launch App

A tag inlay on a round stand at the centre of a ring of glass tiles: a code symbol, an app window, a locked record in a cube, a product record card with a check, a database, a small robot, and a node graph.

Brand developers

You have an app or a site and a product line. Put the verify flow, the product record and the assistant inside what you already run.

Put it in your app

AI builders

You build with ChatGPT, Claude, Gemini or your own agent. Read product records through MCP, with no key for the public tools.

Agent API and MCP

Protocol developers

You want the contracts, the lifecycle and the addresses. Everything is open source and live on Base Sepolia.

Contract reference

For brand developers

Put it in your app, not next to it.

Your customers should never leave your brand to check a product. These are the four pieces you wire into what you already run. None of them needs a wallet, a token or any blockchain code on your side.

The verify link

Every tag opens the product's record at verify.tagit.network. The link uses the GS1 Digital Link format, so your existing product URLs and retailer systems can resolve it too. Wrap it in your own page or link straight to it.

GS1 Digital Link · /01/{GTIN}/21/{serial} · no key

The assistant in your app

The consumer agent that answers questions about a product is embedded in your app, your site or your assistant, not a separate download. Embedding is scoped with your developers in the pilot.

Scoped per pilot

Any model over MCP

A public, read-only MCP server exposes three tools: verify a product, read its history, check whether it is flagged. The gateway MCP adds twelve more behind an API key.

verify.tagit.network/mcp · api.tagit.network/mcp

Product passport data

The same endpoint serves the product's data as a credential in the W3C Verifiable Credential shape, compatible with the EU Digital Product Passport. The credential is unsigned today, and the register says so.

EU DPP compatible data · JSON-LD

Writes to the record, creating products, binding tags and flagging, go through the business app or the gateway with an API key. Your systems never hold keys to the chain.

Scope an integration

Quick start

Read an asset record in one call.

TAGITCore exposes every asset record on-chain: owner, timestamp and lifecycle state. Query it with viem against the public Base Sepolia RPC — no API key, no account.

viemFoundrySolidity 0.8.28

read-asset.tsBase Sepolia

// Read an asset record from TAGITCore (Base Sepolia proxy)
// Requires: npm install viem
// ABI: tagit-contracts/out/TAGITCore.sol/TAGITCore.json
import { createPublicClient, http } from "viem";
import { baseSepolia } from "viem/chains";

const client = createPublicClient({
  chain: baseSepolia,
  transport: http(),
});

// getAsset(tokenId) → [owner, timestamp, state, flags, reserved]
// States: 0 NONE · 1 MINTED · 2 BOUND · 3 ACTIVATED
//         4 CLAIMED · 5 FLAGGED · 6 RECYCLED
const [owner, timestamp, state] = await client.readContract({
  address: "0x3aDc7EFDb58Ae85483eFf5D4966D916185f31d1D",
  abi: TAGITCoreABI,
  functionName: "getAsset",
  args: [1n],
});

Proven with external clients

Two clients, no TAG IT code, same answer.

A plain JSON-RPC call to the public MCP server and a read through the SDK built from source both resolve token 1 to the same on-chain record on Base Sepolia. Outputs below are real and dated; nothing is simulated.

MCP · verify.tagit.network/mcp · public, read-only2026-10-16

curl -s -X POST https://verify.tagit.network/mcp \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call",
       "params":{"name":"verify_asset","arguments":{"token_id":"1"}}}'

// structuredContent, abridged — 2026-10-16
{ "token_id": "1", "state": "RECYCLED", "state_code": 6,
  "authentic": false, "flagged": false,
  "chainRef": { "chain_id": 84532,
                "contract": "0x3aDc7EFDb58Ae85483eFf5D4966D916185f31d1D",
                "block_number": 48200883 },
  "network": "base-sepolia", "audit_status": "unaudited",
  "production_ready": false }

SDK · built from source · Base Sepolia RPC2026-10-16

// Built from source (tagit-sdk, main @ 5fbe8ca). Public RPC, no key.
import { createAgentClient, createTagitCoreReader, getAddresses, baseSepolia } from "@tagitnetwork/sdk";
import { createPublicClient, http } from "viem";

const client = createAgentClient({ rpcUrl: "https://sepolia.base.org" });
await client.identity.getAgent(1n);
// → { wallet: "0xDb8A…d63F", registeredAt: 1775167296n, active: true }

const pc = createPublicClient({ chain: baseSepolia, transport: http("https://sepolia.base.org") });
const core = createTagitCoreReader(pc, getAddresses(84532).TAGITCore);
await core.getAsset(1n);  // → { owner: "0x458B…Cb3D", state: 6 /* RECYCLED */, flags: 0 }
await core.totalSupply(); // → 58n

The gateway MCP at api.tagit.network/mcp exposes twelve more tools behind an API key; the SDK is not yet on npm, so clone and build it. Both facts are tracked in the claim register.

Documentation

Start where your integration starts.

Live

Architecture

Base L2 execution settling to Ethereum today. EigenDA data availability and CCIP interop are roadmap items, documented as such.

Architecture overview

Testnet

Smart Contracts

Six core modules: 30 contracts, 21 interfaces and 6 libraries built with Foundry; 17 public addresses on Base Sepolia.

Contract reference

Live

Asset Lifecycle

The seven-state machine every asset moves through: NONE, MINTED, BOUND, ACTIVATED, CLAIMED, FLAGGED, RECYCLED.

Lifecycle guide

Live

NFC Hardware

NTAG 424 DNA — 25 mm tamperproof tag, AES-128 · SUN authentication · CC EAL4+ certified chip. Chip selection and tag-encoding guides for item-level deployment.

Chip selection guide

Testnet

Agent API

Six agent services, five registered on-chain. GET /api/v1/agents is public; invoking a skill, /mcp and /a2a need an API key.

Agent architecture

In Progress

SDK

TypeScript client for the ERC-8004 agent layer (identity, reputation, validation, staking), A2A, and TAGITCore reads plus capability-gated writes. Not yet published to npm; build from source.

JavaScript SDK

Core modules

Six Solidity modules run the protocol.

Each module owns one concern. Together they cover identity, access, recovery, governance, treasury, and incentives.

TAGITCore

ERC-721 digital twins and the lifecycle state machine

TAGITAccess

BIDGES badges — soulbound identity plus capability tokens

TAGITRecovery

AIRP dispute resolution for lost, stolen, or flagged assets

TAGITGovernor

Multi-house DAO governance with timelocks and veto

TAGITTreasury

Fee collection and protocol revenue distribution

TAGITPrograms

Incentive programs, rewards, and enrollment tracking

Base block time: ~2s; Base block time
Chain ID: 84532; Chain ID
Asset states: 7; Asset states
L1 finality (Base): 7-day; L1 finality (Base)
Public addresses: 17; Public addresses
Libraries: 6; Libraries

Base Sepolia testnet. Mainnet is audit-gated, targeted H1 2027.

Build with us.

The protocol is in active development on testnet. Read the source, file issues, or ask integration questions directly.

GitHub organization

9 public repositories — contracts, services, indexer, SDK, and more.

Discord

Integration help, protocol discussion, and release notes.