MetaFishtank
DevelopersBuilt on BNB Chain

Build on living, player-made characters

Players draw. The Anima Engine reads what they made and turns it into a character with traits and a temperament; MAP gives it a portable identity and state your game can read — and, with permission, add to. DrawFish runs the first steps today: the drawing and the AI judge that validates it. The rest is in design.

Request early accessRead the docs
The idea

The character stays. The game changes.

A drawing is the start of a character's life, not a finished image. Games become places it visits — and every visit can leave a mark.

  1. 1ExpressionA player drawsLive in DrawFish
  2. 2InterpretationAI reads the drawingLive in DrawFish
  3. 3IncarnationTraits and behaviorIn design
  4. 4InteractionPlayed in any gameIn design
  5. 5EvolutionHistory written backIn design
Architecture

Three layers, one character

MetaFishtank is not a new chain. It is an application and middleware stack on BNB Smart Chain: BNB Chain runs it, MAP defines the asset language, Anima gives the asset life.

Tank EcosystemApplication layer — the games where characters are created, played and grow
  • DrawFish — live in DrawFish
  • Partner games — coming
  • Open Ocean routing — in design
Anima EngineIntelligence layer — reads what a player made and compiles it into game data
  • Validation (AI judge) — live in DrawFish
  • Feature extraction — in design
  • Trait compiler — in design
  • Behavior profiles — in design
  • Developer runtime — in design
MAP — MetaFishtank Asset ProtocolProtocol layer on BNB Chain — portable identity, state, permissions and cross-game evolution
  • AgentNFT — in design
  • Trait registry — in design
  • State registry — in design
  • Game adapter registry — in design
  • Verification registry — in design
MAP

A protocol for portable characters

A set of Solidity contracts rather than one big NFT: minimal state on-chain, rich history in events. Token, treasury and market contracts stay separate from it.

  • MAPAgentNFTIn designERC-721-compatible ownership and the character's canonical identifier.
  • MAPTraitRegistryIn designCanonical trait namespaces and normalized values every game can read.
  • MAPStateRegistryIn designVersioned state roots, progression summaries and verification checkpoints.
  • MAPGameAdapterRegistryIn designApproved games, their namespaces, read/write permissions and revocation.
  • MAPVerificationRegistryIn designSignatures, attestations and proof references for creation and sensitive updates.
Socket interfacePreview
// MAP socket — what a game reads and writes (litepaper §4.4)
function getTrait(uint256 tokenId, bytes32 traitKey)
    external view returns (int256);

function getAgentState(uint256 tokenId)
    external view returns (bytes32 stateHash, uint64 nonce);

function submitStateUpdate(StateUpdate calldata update, bytes calldata signature)
    external;

Controlled write-back In design

A game can only add to a character inside the space it was granted:

  • A game registers an adapter and asks for its own namespace
  • Writes are scoped to that trait or state namespace
  • Every update carries a nonce against replay
  • Sensitive updates need an EIP-712 signature from an authorized service
  • Rate limits and value bounds per adapter
  • Pause and revocation for a compromised integration
Anima Engine

From a drawing to a character

Anima turns what a player made into structured, reproducible data — and keeps AI computation apart from ownership. The first two steps already run in DrawFish.

  1. 1CaptureStrokes, colors, geometry and timing of the drawingLive in DrawFish
  2. 2ValidationIs it a fish? Category, anti-abuse and creation rulesLive in DrawFish
  3. 3Feature extractionShape, symmetry, palette and stroke style as numbersIn design
  4. 4Trait compilationBounded, versioned game attributesIn design
  5. 5Behavior profileCuriosity, cooperation, risk — how it tends to actIn design
  6. 6Identity packagingVisual hash, DNA hash and a signed payloadIn design
  7. 7MAP commitOwnership-critical state goes on-chainIn design

Developer runtime In design

For studios: describe a role and its limits, get structured data a game can actually use — without building an AI stack.

  • Developer intent → agent template
  • Developer intent → NPC configuration
  • Personality and action parameters
  • Controlled memory and summaries
  • Validation hooks and signed state payloads
  • Runtime adapters for game engines
Tooling

SDKs and APIs

Everything a studio needs to read characters, write back and test — none of it public yet. Request early access to shape it with us.

  • TypeScript SDKRead characters, submit state, listen for events.Coming
  • REST / RPC state APITraits and state over plain HTTP.Coming
  • Solidity interfacesThe MAP socket for on-chain games.Coming
  • Unity toolkitCharacters as prefabs, state as components.Coming
  • Unreal toolkitThe same model for Unreal projects.Coming
  • Event & indexer APIsEvery state change, queryable.Coming
  • Anima APIInterpretation and behavior as a service.Coming
  • Testnet sandboxTest characters and adapters on BSC testnet.Coming
  • Adapter templatesA starting point for your namespace.Coming
  • Integration dashboardKeys, namespaces, usage and logs.Coming
TypeScript SDKPreview
// Preview — the SDK is in design; package and method names may change
import { createClient } from "@metafishtank/sdk";

const map = createClient({ network: "bsc-testnet", apiKey: process.env.MAP_API_KEY });

// a player brings their character into your game
const agent = await map.agents.get(tokenId);
spawn(agent.visual, { speed: agent.traits.speed, curiosity: agent.behavior.curiosity });

// write back what happened — only inside your approved namespace
await map.state.submit({ tokenId, namespace: "my-game", update: { xp: 120, achievement: "first-boss" } });
ECS

Games that add to a character get the credit

The Evolution Contribution Score is an open, auditable record of which games gave a character its history — the basis for recognising developers as co-creators.

  • Verified experience gained
  • Achievements unlocked
  • Skills or traits contributed
  • Active time and retention
  • Durable cross-game state
In design

Building a game? Bring it early.

Tell us what you're making. Early partners get the sandbox first and help decide what the SDK looks like.

Request early access