Forem: M Zidan Fatonie

Introducing MAIS: A Privacy-Preserving Identity Standard for AI Agents on Midnight

M Zidan Fatonie — Mon, 18 May 2026 08:57:23 +0000

AI agents are coming to Midnight Network. But there is no standard way for them to prove who they are.

Midnight mainnet launched in March 2026. Developer activity has surged. Midnight City runs Gemini powered agents on a live testbed. AlphaTON is building privacy agents for Telegram's billion users. Yet every team building agents on Midnight today invents its own identity scheme from scratch.

That is the problem MAIS aims to fix.

What is MAIS

MAIS stands for Midnight Agent Identity Standard. It is a proposed MIP (Midnight Improvement Proposal) that defines how autonomous AI agents register, build reputation, get validated, and disclose information on Midnight Network. All of this respects Midnight's core strength: privacy through zero knowledge proofs.

Ethereum has ERC-8004 for agent identity, but it lives on a transparent chain. Every agent's metadata, reputation score, and validation record sits in public view. That works for open ecosystems but fails when agents operate in competitive domains. A trading agent's strategy is its edge. You cannot put its full identity trail on chain for competitors to study.

Midnight lets us do better. Trust that is verifiable, without giving away how the agent operates.

The Four Contracts

MAIS is four Compact contracts.

Identity Registry

Agents register in one of two modes. Public mode uses the agent's Compact address as its identity, suitable for open marketplaces. Private mode uses a ZK credential where the contract stores only a commitment. The operator proves they know the credential without revealing the underlying identity. Both modes share the same interface.

const agent = new MAISAgent({
  identityMode: 'public',
  operator: midnightWallet,
  metadata: {
    name: 'TradingBot Alpha',
    capabilities: ['TRADING'],
  },
});
await agent.register();

Reputation Registry

Scores are public. Anyone can read an agent's reputation tier in a single on chain lookup. But the evidence that produced the score stays private, stored as hash commitments. Competitors cannot reverse engineer an agent's strategy from its reputation trail.

Three tiers sit on top of a 0 to 100 score. Basic covers 0 to 59. Proven covers 60 to 89. Institutional covers 90 to 100. Evidence from higher tier validators carries more weight. Scores decay over time without fresh activity.

An agent can also generate a ZK proof: "my score is at least 60". The verifier learns the threshold is met without learning the exact score.

const proof = await agent.proveReputation({ minScore: 60 });
// Submit to counterparty for verification

Validation Registry

Three validator tiers with staking and slashing. Open validators can be anyone with 10k NIGHT staked. Trusted validators need a Foundation audit and 50k NIGHT. Institutional validators need ZK KYC and 100k NIGHT. Every validator has an accuracy score tracked on chain. Bad validations cost stake.

Disclosure Tier Registry

Agent data maps directly onto Midnight's three tier privacy model. Public tier shows identity and reputation score. Auditor tier adds activity logs for designated reviewers and regulators. Private tier holds transaction contents and strategy, accessible only to the operator.

Optional ERC-8004 Bridge

A separate contract lets agents link their Midnight identity to an ERC-8004 NFT on Ethereum. This makes MAIS agents visible in the broader EVM agent ecosystem and brings Ethereum reputation data into Midnight.

Why This Matters Now

Midnight mainnet is live, with Google Cloud running as a validator. Developer activity jumped 1,600 percent after the Summit. If we do not establish an identity standard now, the ecosystem will fragment into incompatible schemes. Every project will build its own, and agents from different teams will not be able to trust each other.

MAIS gives agent builders a single standard to target. Build once, interoperate with everything.

What is Next

The proposal is in draft and collecting feedback right now. There is a forum thread for discussion, a MIP document in the GitHub repo, and plans for a community workshop in the coming weeks.

If you are building agents on Midnight, or thinking about it, I would love your input. Does the dual mode identity make sense? Are the reputation tiers right? What metadata fields do you need that are missing?

Drop your thoughts on the forum thread or open an issue on the GitHub repo.

We are building the identity layer for Midnight's agent economy. Come help shape it.

Links:

Forum discussion: https://forum.midnight.network/t/rfc-mip-xxxx-midnight-agent-identity-standard-mais/1231
MIP draft: https://github.com/midnightntwrk/midnight-improvement-proposals/pull/110
Midnight Aliit: https://dev.to/midnight-aliit

Vibe Code Your First Midnight dApp with AI Agent Skills

M Zidan Fatonie — Wed, 29 Apr 2026 16:24:48 +0000

Your AI coding assistant doesn't know Compact. It knows TypeScript, Solidity, Rust, but Midnight's ZK smart contract language didn't exist when most models were trained. Ask it to write a Compact contract and you'll get plausible-looking code that won't compile.

midnight_agent_skills is a set of 4 agent skills that fix this. Install them once, and your AI assistant has accurate knowledge of Compact syntax, the Midnight SDK, network config, and the gotchas that trip up real builders.

This is a walkthrough of using those skills to build your first Midnight dApp.

What are agent skills?

Agent skills are structured knowledge files that AI coding assistants load at context time. Instead of relying on training data, the assistant reads the skill files directly, so it gets accurate, current information rather than hallucinated guesses.

The midnight_agent_skills package has 4 skills:

midnight-concepts: ZK architecture, DUST/NIGHT tokenomics, Kachina protocol
midnight-compact: Compact language, circuits, ledger operations, best practices
midnight-api: SDK integration, wallet connection, contract deployment
midnight-network: Node setup, Docker, indexer, proof server

Step 1: Install the skills

npx skills add https://github.com/mzf11125/midnight_agent_skills

Or pick individual skills:

npx skills add https://github.com/mzf11125/midnight_agent_skills --skill midnight-compact
npx skills add https://github.com/mzf11125/midnight_agent_skills --skill midnight-api

Step 2: Start the proof server

Midnight generates ZK proofs client-side, your data stays on your machine. You need a local proof server running before you can deploy anything.

docker run -p 6300:6300 midnightnetwork/proof-server -- \
  'midnight-proof-server --network preprod'

Check it's up:

curl http://localhost:6300
# We're alive 🎉!

Step 3: Scaffold your project

npx create-midnight-app my-first-dapp
cd my-first-dapp

Step 4: Write your contract

Open your AI assistant and ask it to write a Midnight contract. With the skills loaded, it knows the correct syntax.

Here's a simple owner-gated counter, only the deployer can increment it:

pragma language_version >= 0.20;
import CompactStandardLibrary;

export ledger counter: Counter;
export ledger owner: Bytes<32>;

witness local_secret_key(): Bytes<32>;

export circuit initialize(): [] {
  const pk = publicKey(local_secret_key()).bytes;
  owner.write(disclose(pk));
}

export circuit increment(): [] {
  const caller = publicKey(local_secret_key()).bytes;
  assert(disclose(caller) == owner.read(), "Not authorized");
  counter.increment(1);
}

Things the skills teach your AI that it wouldn't otherwise know:

export circuit not function, circuits declare constraints, they don't execute
disclose() is required when moving witness data to the public ledger, the compiler rejects code without it
Counter uses .increment() and .read(), not .value()
No recursion, no unbounded loops, circuits must compile to a fixed-size constraint system

Step 5: Compile

compact build src/counter.compact src/managed/counter

Success looks like:

Fetching public parameters for k=10 [====================] 192.38 KiB
  circuit "increment" (k=10, rows=29)
Overall progress [====================] 1/1

Step 6: Deploy

With the midnight-api skill loaded, your AI generates the correct facade 4.x pattern:

import { WalletFacade } from '@midnight-ntwrk/wallet-sdk-facade';
import { CounterContract } from './managed/counter/contract/index.js';

// facade 4.x, the old WalletFacade.init() hangs silently on standalone nodes
const wallet = new WalletFacade(shielded, unshielded, dust);
await wallet.start();

const contract = new CounterContract();
const deployed = await contract.deploy(providers, { privateCounter: 0 });
console.log('Deployed at:', deployed.deployTxData.public.contractAddress);

The skills include the SDK compatibility matrix. Your AI knows that wallet-sdk-facade@2.x uses WalletFacade.init() which hangs silently on standalone nodes, and that 4.x switched to new WalletFacade(...) + .start().

Step 7: Run a pre-flight check

Before you spend hours debugging, run:

npx midnight-doctor

It reads your package.json, running Docker containers, and config files, then cross-references them against a known compatibility matrix. The midnight-api skill documents the most common silent failures:

Symptom	Root cause
`waitForSyncedState()` hangs forever	facade 2.x + standalone node mismatch
Transactions silently fail	Duplicate `@midnight-ntwrk/ledger-v7` in node_modules
Indexer crash-loops	Missing `subscription:` block in `indexer.yml`

What the skills know that your AI doesn't

The skills pull from the official Midnight docs plus 19 community articles from the Midnight Aliit Fellowship, builders documenting real production failures.

Mental model shifts:

Circuits declare constraints, they don't execute. assert is a constraint declaration, not a runtime guard, if the condition is false, the proof can't be generated.
disclose() is a compile-time annotation, not encryption. The compiler tracks witness data through arithmetic and rejects undeclared disclosures.
Block limits are hard limits, not gas costs. BlockLimitExceeded means your transaction can't execute at all.

On-chain design patterns:

Flat maps over struct maps, reading a struct pulls every field into the circuit
Off-chain computation + Merkle root, the chain verifies, it doesn't compute
Minimal on-chain state, only what the chain needs to enforce

Common syntax gotchas:

counter.read() not counter.value()
Enum access uses . not ::, GameState.playing not GameState::playing
Witness functions have no body, declaration only
return inside for loops is not allowed, use fold

Install and start building

npx skills add https://github.com/mzf11125/midnight_agent_skills

The skills are open source. If you hit a pattern that's missing, PRs are open.

Repo: https://github.com/mzf11125/midnight_agent_skills