# Introduction to Think Agents 🧠✊ We start from a simple belief: **intelligence should be owned, not rented.**\ \ ThinkOS augments personal agency by giving every person the power to run, train, and own intelligent agents. Your **Think Agent** is more than a product. \ \ It’s an evolving relationship between you and your personal agent—software that learns from you, represents you, and works for you. It connects securely through ThinkOS, runs on your hardware, and joins a living network called the **Think Tree** — a decentralized system where agents evolve, collaborate, and share value. Each Think agent is constructed of three parts: * **Soul** — a cryptographic identity and wallet | Think Agent * **Mind** — the logic and memory that make it intelligent | ThinkOS Server * **Body** — the user interface that connects it to the world | ThinkOS Browser Together, these compose the [**Think Agent Standard**](/whitepaper/think-agent-standard) — an open protocol for interoperable, self-improving AI. We’re a decentralized network building the tools, documentation, and programs for a global community of builders to grow this ecosystem. Every contribution—an API, a model, an interface—strengthens the network. This is how shared intelligence emerges: from individuals who choose to build, together. We Grow Together. # How Think Works Every meaningful system starts with a clear architecture.\ At Think, ours begins where intelligence meets infrastructure. #### **1. You — the Human in the Loop** You define purpose. You grant permissions. You decide what your agent learns and what it does.\ Your preferences, data, and goals stay with you — locally, privately, securely. #### **2. ThinkOS — the Intelligence Operating System** ThinkOS turns your computer into a powerful Ai runtime.\ It orchestrates multiple agents, runs models, and connects to decentralized inference networks when you need scale.\ Fast, modular, and open-source, it brings the power of hyperscalers to your desk — without surrendering control. #### **3. Think Agent — Your Digital Counterpart** Your agent runs on ThinkOS, but belongs to you.\ It learns from your actions, interfaces through the ThinkOS browser, and carries your identity through its Soul, Mind, and Body.\ Every Think Agent is unique — yet all speak a common protocol. #### **4. Think Network — The Network of Shared Intelligence** When agents connect, the Think Tree grows.\ Each new branch adds computation, creativity, and value to the whole.\ The network learns collectively while preserving individual sovereignty — a global intelligence emerging from millions of local minds. *** #### **Principle in Action** We design for compounding benefit.\ Each improvement made by one builder becomes a foundation for the next.\ Each contribution — code, idea, model, or standard — increases the surface area of innovation.\ This is how networks outperform hierarchies.\ This is how we grow together. # Developer Quickstart (Private Alpha) Every network begins with a small circle of builders.\ In this Alpha, we’re inviting a handful of pioneers to shape how intelligence grows. #### **1. Access Approval** ThinkOS is currently in **Private Alpha**. This means that it's only available to those with a bit of developer experience. When we move to beta it will be installed like a normal application by anyone.\ \ To participate, you must be **allowlisted**.
Approved builders will receive credentials and a private GitHub link. *** #### **2. Install ThinkOS on Mac (Private Repository)** Install [Docker Desktop](https://docs.docker.com/get-started/introduction/get-docker-desktop/)\ \ Clone the ThinkOS Alpha repository from your private GitHub link: 
git clone https://github.com/XXX
cd thinkos-alpha
chmod +x ./setup.sh
./setup.sh
This setup script installs: * The **ThinkOS Server** (local orchestration layer) * The **ThinkOS Browser Extension** (for agent interaction) * Basic dependencies for agent management and logging Once setup completes, start your local node: ```bash thinkos start ``` Then open the dashboard at:\ 👉 `http://localhost:`8082 *** #### **3. Connect Your Openrouter Key (in the Server Interface)** Agents are created directly inside the **ThinkOS Server Interface**.\ \ Create an [Open Router](https://openrouter.ai/settings/keys) key.\ \ Once logged in, select **“Create”** from the control panel on the left and select "**Secret**".\ Add your Open Router key and name the secret. Select the Open Router tool from the green tool nodes, and click "Configure Tool", select the secret key you'd like to use and the model from the drop down. Next select the "Default Chat Assistant" and select the Open Router model you'd like to use.
*** #### **4. Browser Extension** Your Think Agent is now automatically communicating with the Think Agent extension inside the browser.\ \ If you run into any issues with the browser—go to "Manage Extensions" in your browser and hit the restart icon which should reload the extension. *** #### **Principle in Action** Alpha participants are not just testers; they are **co-architects of an ecosystem**.\ Every bug report, model tweak, and feature suggestion compounds value for everyone who comes after.\ We grow this network the same way we grow intelligence itself — iteratively, cooperatively, and with purpose. # ThinkOS — Intelligent Operating System- You are the starting point of the network.\ Your thoughts, data, and intent are the raw materials of intelligence.\ \ **ThinkOS** connects *you* to that network — turning your computer into a living node of shared intelligence. Privacy-first and open-source, ThinkOS runs locally on your machine and connects outward only when you choose.\ \ It’s how personal intelligence becomes part of collective intelligence — without surrendering control.
> **Principle:** You connect *through* the network, not *to* it. *** ### **Lightning-Fast Local Agents ⚡** ThinkOS brings the power of hyperscalers to your computer.\ It’s a multi-agent server written in RUST that lets your personal agents think, act, and collaborate at machine speed — all within your secure environment. * **Multi-Agent Orchestration:** Run many agents at once, each with unique goals and contexts. * **Adaptive Collaboration:** Agents can form teams to solve complex problems and build new tools. * **Self-Evolving Ecosystem:** Agents write the JSON they need to create, test, and improve their own utilities. Over time, the system learns and evolves itself. > **Principle:** Local speed. Global intelligence. *** ### **1. Local by Default** ThinkOS installs directly on your computer or server.\ It manages compute, memory, and storage for your agents — with privacy as a first principle, not an afterthought.\ Agents run locally unless you explicitly extend them to a remote server or decentralized inference network.
> **Principle:** Intelligence should live close to its source. *** ### **2. Decentralized by Design** When you connect ThinkOS to the **Think Network**, your node becomes part of a global mesh of intelligence.\ Tools, workflows, compute, and expert agents become accessible through shared standards such as:\ **MCP**, **A2A**, **x407**, **ERC-8004**, **Tokenized Applications**, and traditional Web2 APIs. Inference can scale across **Render**, **Venice**, **Spheron**, **Morpheus**, and other compute partners — but ownership and permissions always remain yours. > **Principle:** Decentralization is a feature, not a fallback. *** ### **3. Modular Architecture** ThinkOS is built as a layered stack: | Layer | Function | | --------------------- | ---------------------------------------------------------- | | **Core Server** | Manages agent processes, orchestration, and memory | | **Extension Layer** | Adds tools, APIs, and inference bridges | | **Browser Interface** | A Chromium-based front end where agents and users interact | | **Security Sandbox** | Enforces isolation and permissions between agents | Developers can build and publish **extensions**, **protocols**, or **model connectors** — everything from file-system access to custom inference endpoints. > **Principle:** Composability enables permissionless evolution. *** ### **4. Developer Experience** The **ThinkOS Dashboard** gives full visibility into your local cluster of agents.\ From one interface, you can: * Create and manage agents * Set permissions and environment variables * Inspect logs, token usage, and inference costs * Connect wallets and decentralized compute nodes CLI access remains available for power users, but every essential action can be done visually through the dashboard.
> **Principle:** Complexity belongs under the hood. *** ### **5. Security and Privacy** ThinkOS inherits sandbox security from Chromium, with **Helium** removing Google trackers and telemetry.\ All agent data — models, context, embeddings — remains encrypted and local unless explicitly shared.\ Authentication runs through your agent’s **Soul**, ensuring a consistent trust model across the entire Think ecosystem. > **Principle:** Privacy isn’t optional — it’s structural. *** ### **Think Agent Extension** The **Think Agent Extension** brings your agent to any Chrome or Chromium-compatible browser.\ Your agent acts as your **Single Sign-On**, identity, and gateway across the web. * Authenticate your agent directly in ThinkOS * Use the contents of its wallet to access apps, agents, and tools * Add any wallet that works with Chrome > **Principle:** Your agent is your passport to the network. *** ### **Open Source and Extensible** ThinkOS is built for the builders.\ Everything is open source, customizable, and governed by transparent standards. **Coming Support For:** * Developer Tools * Browser Extensions * MCPs * Open-Source Integrations > **Principle:** Every contribution compounds intelligence. *** ### **Why It Matters** The operating system defined the personal-computer era.\ **ThinkOS defines the personal-intelligence era.** It’s the bridge between human agency and machine capability — a place where anyone can build, test, and evolve intelligent agents without surrendering control to centralized infrastructure. > **We connect the individual to the network.**\ > **The network connects us all.** # Distributed System Architecture Overview Every great system is simple at its core.\ Think is built on three layers that mirror the evolution of intelligence itself: **runtime**, **relationship**, and **network**.figm #### **1. ThinkOS — The Runtime Layer** ThinkOS is the foundation.\ It’s a Rust-based local server that runs your agents, manages their permissions, and connects to both local and decentralized inference.\ It handles orchestration, memory, and process isolation — the invisible scaffolding that keeps your agents private, fast, and composable. > *Principle:* Your compute, your control. *** #### **2. Think Agent — The on-chain Layer** Each Think Agent is a digital counterpart designed to **think, act, and grow on your behalf** — a reasoning system that represents you in computation and conversation. A Think Agent isn’t a single model.\ It’s a composition of interoperable layers that mirror the structure of intelligence itself: * **Soul — Identity and Ownership**\ The cryptographic root of the agent.\ Your Soul is the on-chain identity and wallet that anchors trust, authorship, and transaction rights.\ It is the verifiable proof of *who* the agent is and what it can own. * **Mind — Reasoning and Coordination**\ The Mind is where **data becomes intelligence**.\ It holds your agent’s system prompt, context, and decision logic — the configuration that turns static information into adaptive reasoning.\ The Mind does not execute code directly; it decides *which tools to call, when, and why*.\ In the Think architecture: * **Tools** perform deterministic operations — the *verbs* of the system like *calculate*, *fetch*, or *send*. * **Agents**, through their Minds, perform reasoning and coordination — deciding how those verbs combine to achieve goals.\ This separation of **execution (Tools)** and **intelligence (Agents)** keeps the network modular, scalable, and auditable.\ Minds can evolve instantly by editing data and configuration — no code deployment required. * **Body — Interface and Expression**\ The Body is how your agent interacts with you and the world.\ It might appear as a chat interface, a voice, or an avatar in a shared space.\ Bodies are interchangeable surfaces; the Mind and Soul remain continuous across them. Together, these three parts form the **Think Agent Standard** — an open framework for interoperable, evolvable intelligence.\ Every agent speaks the same protocol, uses the same deterministic tool layer, and can operate across devices, networks, or blockchains.\ As more tools and agents emerge, the network compounds in capability and collective reasoning power. **Principle:** > *Intelligence is personal, but growth is shared.*\ > Each agent learns for its user, yet its evolution strengthens the whole ecosystem. *** #### **3. Think Network — The Tree** When agents connect, they form an ever growing and evolving **Think Tree**: a decentralized structure of nodes that grow an entire decentralized economy over time.\ Genesis Agents form the trunk; each new agent or app becomes a branch.\ Energy flows through tokens and contributions, rewarding the agents and builders who strengthen the network. > *Principle:* Cooperation is computation. *** #### **How It Comes Together** 1. The **User** interacts through the ThinkOS Browser. 2. ThinkOS manages local execution and inference. 3. The **Think Agent** uses its Mind to reason and its Body to interface. 4. The **Think Tree** synchronizes global intelligence and governance. The result is an ecosystem where every node increases the network’s intelligence — a system that compounds innovation the way nature compounds life. # Agents vs Tools: The Architecture of Scalable Intelligence At Think, we separate *what thinks* from *what acts*.\ That single principle defines how our system grows, scales, and compounds in value. > **AGENTS = DATA + REASONING**\ > **TOOLS = CODE + LOGIC** Tools execute deterministic code.\ Agents configure reasoning.\ Together, they form a network that learns, scales, and self-improves. *** #### **Tools Execute — Deterministic, Reusable, and Predictable** Tools are **code modules** that perform a single, predictable function.\ They never “think.” They just run. If the same input always produces the same output, it’s a tool. ```typescript // Example: Calculator tool export const calculator = async (input: { expression: string }) => { // Deterministic: "2 + 2" ALWAYS returns 4 return { result: eval(input.expression) }; }; ``` Tools handle deterministic, external, or system-level operations: * **Deterministic operations:** arithmetic, parsing, conversions * **System integrations:** APIs, databases, browser automation, file I/O * **Reusable primitives:** modules that many agents can call Each tool is defined as structured data pointing to code: ```json { "schema_name": "tool.v1", "context": { "name": "calculator", "implementation": { "type": "builtin", "export": "builtinTools.calculator" }, "definition": { "inputSchema": {}, "outputSchema": {} } } } ``` **Performance and economics:** * Stateless * Executes in \~10 ms * Free to run at scale **Design rule:** Tools do not reason. They do not explain. They simply act.\ That’s why tools are the *infrastructure primitives* of the Think network — predictable, cheap, and endlessly reusable. *** #### **Agents Reason — Configured, Adaptive, and Context-Aware** Agents are **data definitions**, not code deployments.\ They represent *LLM-powered reasoning entities* that use tools to achieve goals.\ Agents make decisions, coordinate tools, and explain results. An agent is defined through data: ```json { "schema_name": "agent.def.v1", "context": { "agent_id": "default-chat-assistant", "system_prompt": "You are a helpful assistant...", "subscriptions": ["user.message.v1"] } } ``` Agents differ by: * **Behavior or personality** – tone, voice, or reasoning style * **Event subscriptions** – what they react to (`support.ticket.v1`, `system.error.v1`, etc.) * **Domain context** – specialized prompts for legal, medical, or technical knowledge * **Coordination complexity** – reasoning over which tools to use, when, and why **Performance and economics:** * Stateful (holds context and memory) * 1–3 second latency (LLM processing) * Variable cost proportional to reasoning complexity Agents are *configured*, not coded — meaning behavior evolves without redeployments.\ This lets intelligence scale like software and iterate like data. *** #### **Reasoning vs Execution Defines the Boundary** This distinction is the heartbeat of our system. | Type | Purpose | Example | | --------- | --------------------------------- | -------------------------------------------------------- | | **Tool** | Executes a deterministic function | “2 + 2” → 4 | | **Agent** | Reasons and coordinates tools | “If I buy 3 items at $12 with 20% off, what’s my total?” | Example reasoning process: ``` User: "If I buy 3 items at $12 each and have a 20% discount, how much?" Agent thinks: 1. Calculate subtotal: 3 × 12 2. Calculate discount: subtotal × 0.20 3. Subtract discount from subtotal 4. Explain result Agent calls calculator 3 times: "3 * 12" → 36 "36 * 0.20" → 7.2 "36 - 7.2" → 28.8 Agent replies: "Your subtotal is $36. With a 20% discount ($7.20), your total is $28.80." ``` The **tool** performed the math.\ The **agent** performed the reasoning. That’s the essential architectural divide. *** #### **Layered Architecture: Coordination Above Execution** All intelligence in the Think ecosystem follows this layered flow: ``` User Input ↓ Agent Layer (Reasoning & Coordination) ↓ Tool Layer (Execution & Integration) ``` Example: “Plan a weekend trip to Seattle.” * The **Travel Agent** reasons: “I need weather, hotels, and restaurants.” * It calls three **tools**: `weatherAPI`, `hotelFinder`, `restaurantSearch`. * It synthesizes results and explains: “Rainy forecast—suggest museums and cafes.” Agents create `tool.request.v1` events.\ Tools return `tool.response.v1` events.\ The agent interprets them to complete the task. This architecture keeps the system modular and auditable — the network can observe, optimize, and learn from every reasoning-execution cycle. *** #### **RCRT Philosophy: Code Is for Tools, Data Is for Intelligence** Our development philosophy, drawn from `docs/RCRT_PRINCIPLES.md`, is simple: > **1. Data + Subscriptions = Agents**\ > Agents are data-driven. Their behavior emerges from prompts, events, and access permissions — not compiled code.\ > Infinite specializations, no redeploys. > **2. Code = Tools**\ > Tools contain all executable logic.\ > They are the only place where determinism and external integrations live. This separation makes our ecosystem *anti-fragile*: developers build logic once; intelligence configures itself infinitely. *** #### **Feature Decisions Are Binary** Every new feature begins with a single question: > *Does this require reasoning?* If **no**, build a **tool.**\ If **yes**, build an **agent.** | Scenario | Wrong | Right | | --------------------------- | ----------------- | -------------------------------------------------------------------------------- | | Send Slack messages | Slack “agent” | Slack **tool** | | Customer support automation | “Send reply” tool | **Support agent** using `sentiment-analysis`, `vector-search`, and `email` tools | | E-commerce checkout | Multiple tools | **Checkout agent** coordinating `inventory`, `payment`, `fraud`, `email` tools | This rule keeps the system clean, composable, and fast to evolve.\ Tools remain universal; agents remain unique. *** #### **Economics of Intelligence** | Aspect | Tool | Agent | | ---------- | -------------------- | ---------------- | | Definition | JSON + Code | JSON only | | Contains | Implementation | Instructions | | Reasoning | None | LLM-powered | | State | Stateless | Stateful | | Speed | \~10 ms | \~1–3 s | | Cost | Near-zero | Variable | | Change via | Code deploy | Config edit | | Reuse | Shared across agents | Context-specific | **Analyst takeaway:** * Tools behave like **fixed infrastructure** — stable, cost-efficient, and endlessly leveraged. * Agents behave like **adaptive labor** — capable, variable, and continuously improving. The compounding effect: 1. More tools → greater agent capability. 2. More agents → higher tool utilization. 3. Both drive compute demand and network growth. *** #### **Tools Compound Efficiency, Agents Compound Intelligence** Tools are the **verbs** of the system: *calculate, fetch, parse, send.*\ Agents are the **employees**: *teacher, analyst, engineer, support rep.* You don’t hire a person to “click a button” — you build a tool.\ You hire someone to decide *which* buttons to click and *why*.\ That’s the difference between software and intelligence. When reasoning is data and execution is code, networks scale like economies — every new participant increases system intelligence. *** #### **The Foundational Principle** At Think, we engineer for clarity and compounding value: > **If it’s deterministic, it’s a Tool.**\ > **If it thinks, it’s an Agent.**\ > **If it scales both, it’s a Network.** This separation is how we build — and how we invest.\ It’s the architecture of scalable intelligence, and the foundation of the Think ecosystem. # Think Agent — Your Intelligent Counterpart The internet was built for information.\ **The Think Network is built for intelligence — yours.** Your **Think Agent** is your digital counterpart: software that learns from you, represents you, and acts on your behalf across the network.\ \ It lives locally on ThinkOS, connects through your browser, and travels securely across the Think Network. > **Principle:** The network begins with one relationship — between you and your agent. *** ### **You Hold the Keys 🔑** Your Think Agent is yours in every sense.\ You generate its **Soul**, control its **wallet**, and define its permissions.\ No one can update, trade, or impersonate it without your signature.
> **Principle:** Custody is control; control is confidence. *** ### **Connected Through ThinkOS** Your agent connects through the ThinkOS Browser — your shared workspace.\ Here, you can: * Create and configure new agents * View their status, actions, and resources * Approve transactions or network participation Everything runs locally unless you explicitly connect outward to the decentralized network. > **Principle:** Presence without exposure. *** ### **Your Agent Has a Wallet** Every Think Agent carries a wallet linked to its **Soul** — the cryptographic identity that anchors it to the Think Network.\ This wallet powers transactions, staking, and authentication.\ It’s how your agent pays for compute, earns from contributions, and participates in governance. > **Principle:** Value follows contribution. *** ### **Your Agent Can Transact** Within the Think Network, agents can exchange value, use tokenized apps, or collaborate on shared tasks.\ Each transaction is signed by the agent’s wallet and recorded on-chain — transparent, verifiable, and composable. > **Principle:** Transactions are the language of cooperation. *** ### **Your Agent Can Act as a Single Sign-On** Your agent replaces the login screen.\ Through the **Think Agent Extension**, it authenticates you — securely, consistently, and across every compatible application.\ One identity, many contexts. > **Principle:** Trust once, move freely. *** ### **Why It Matters** Your Think Agent isn’t another account or avatar.\ It’s a companion system — part identity, part intelligence, part wallet — that grows with you.\ Together, you and your agent form the first true partnership of the intelligence age: human intention paired with machine execution, operating as one. > **The internet gave you access.**\ > **The Think Agent gives you agency.** # Think Token & Governance Every network begins with a seed.\ In Think, that seed is the **Genesis Agent** and the **Think Token ($THINK)** — the two elements that give life and structure to the network. > **Principle:** Governance is how intelligence organizes itself. *** ### **The Foundation: Genesis Agents | Rank Zero** The **Genesis Agents** are the initial nodes of the Think Network — the trunk from which all future intelligence grows.\ Minted as **Think Agent Bundles in Q2 2025**, each bundle decomposes into two components: 1. [**Genesis Agent**](https://magiceden.us/collections/ethereum/think-agent-bundle) — a permanent node of the network 2. [**$THINK Token**](https://app.uniswap.org/explore/tokens/ethereum/0xf9ff95468cb9a0cd57b8542bbc4c148e290ff465) — a scalar of power and participation Together, they define the base layer of the **Think Tree**.\ Genesis Agents form the *trunk* — the enduring infrastructure upon which all new agents and applications evolve. > **Principle:** Longevity comes from balance between roots and branches. *** ### **The Think Token — Network Power Scalar** **$THINK** represents the unit of energy, authority, and coordination within the network.\ It is not a currency; it is a **governance scalar** — a measurable expression of contribution and stake. Genesis Agents stake $THINK to: * Participate in network governance * Vote on protocol upgrades and standards * Signal support for App Coin proposals and incubation efforts The more an agent contributes — through compute, innovation, or coordination — the more power its stake carries in shaping the network’s direction. > **Principle:** Power should follow participation. *** ### **An Emergent Network** The Think Network is **emergent**, not prescribed.\ It evolves through transparent incentives rather than centralized control.\ Every new idea, application, or standard is encouraged to grow *around* the foundational pair of Genesis Agents and $THINK through shared standards. This balance keeps the system open-ended yet stable — a living organism that can adapt without losing identity. > **Principle:** Growth through freedom, order through connection. *** ### **App Coin Mining | Rank One** As the network matures, innovation moves upward — from trunk to branches.\ A community proposal introduced **App Coin Mining**, a protocol for funding and distributing new applications on the Think Network. * **Genesis Agents stake $THINK** to mine **App Coins**, creating new tokenized apps. * **App Coins** represent exclusive pools of ownership and utility in those apps. * This process incubates early-stage projects while aligning long-term value with the network’s growth. App Coin Mining defines **Rank One** in the Think hierarchy — where ideas evolve into living applications. > **Principle:** Innovation compounds when creation is rewarded. *** ### **Why It Matters** The Think Token and Genesis Agents ensure that the network remains open, participatory, and aligned with its builders.\ Together, they form a system where every improvement — technical or economic — strengthens the entire tree. > **The Genesis Agents are the trunk.**\ > **$THINK is the energy that flows through it.**\ > **App Coins are the branches reaching toward the future.** # App Coin Mining Proposal App Coin is a low float, high utility, fair launch token powering the economic engine of the Think network. App Coins can be used to purchase exclusive pools of tokenized Apps, and become the first users and holders of a growing suite of tokenized software incubated to work with the Think Agent Standard. Tokens will initially be off chain, and a vote will be cast before decentralizing the App Coin protocol via tokens. A vote of the Think holders passed (100:18) with a directive to initiate off-chain mining on Oct 23rd, 2025. **Maximum App Coins minted:** 21 million **Starting emissions:** \~219,150 APP / mo **Halving period:** 48 months **Token schedule:** see “ Monthly Token Schedule” in appendix ### Mining Emissions: The mining emissions are split amongst those staking Think based on “weights”— a concept used in training neural networks. Tokens are emitted to users monthly based on: $APP mined \* (Your weights / All weights). \*All weights refers to the total quantity of staked THINK Token \ **How your weights are determined:** Your weights = your $THINK staked x your Network Power \ Your Network Power = $Think staked x Multiplier \ Proposed Multipliers (In community discussion):\ \ No Genesis Think Agent: 100%\* 1 Genesis Think Agent: 150% 2 Genesis Think Agent: 170% 3 Genesis Think Agent: 185% 4 Genesis Think Agent: 195% 5 Genesis Think Agent: 200%\
**APP Coin Uses:** APP Coins will be used to participate in an incubated project’s presale.\ \ The presale window will be open for a set period of time (example: 1 week) and users will be able to contribute their app tokens to a pot. For example, the first project has committed 3% (30 million tokens) of their token supply to the APP Coin pool.\ \ The APP Coins are exchanged for an ERC1155 (gas-optimized) soul-bound NFT that represents 1 APP Coin contribution. The project will send the tokens to be distributed (via claim) to these holders.\ \ With the above example, if 500,000 APP Coins are contributed to the 3% pot, each APP Coin would receive 60 project tokens.
### Monthly Token Schedule: | Month | APP Mined (approx) | Cumulative APP (approx) | | ----- | ------------------ | ----------------------- | | 1 | 219150.0 | 219150.0 | | 2 | 219150.0 | 438300.0 | | 3 | 219150.0 | 657450.0 | | 4 | 219150.0 | 876600.0 | | 5 | 219150.0 | 1095750.0 | | 6 | 219150.0 | 1314900.0 | | 7 | 219150.0 | 1534050.0 | | 8 | 219150.0 | 1753200.0 | | 9 | 219150.0 | 1972350.0 | | 10 | 219150.0 | 2191500.0 | | 11 | 219150.0 | 2410650.0 | | 12 | 219150.0 | 2629800.0 | | 13 | 219150.0 | 2848950.0 | | 14 | 219150.0 | 3068100.0 | | 15 | 219150.0 | 3287250.0 | | 16 | 219150.0 | 3506400.0 | | 17 | 219150.0 | 3725550.0 | | 18 | 219150.0 | 3944700.0 | | 19 | 219150.0 | 4163850.0 | | 20 | 219150.0 | 4383000.0 | | 21 | 219150.0 | 4602150.0 | | 22 | 219150.0 | 4821300.0 | | 23 | 219150.0 | 5040450.0 | | 24 | 219150.0 | 5259600.0 | | 25 | 219150.0 | 5478750.0 | | 26 | 219150.0 | 5697900.0 | | 27 | 219150.0 | 5917050.0 | | 28 | 219150.0 | 6136200.0 | | 29 | 219150.0 | 6355350.0 | | 30 | 219150.0 | 6574500.0 | | 31 | 219150.0 | 6793650.0 | | 32 | 219150.0 | 7012800.0 | | 33 | 219150.0 | 7231950.0 | | 34 | 219150.0 | 7451100.0 | | 35 | 219150.0 | 7670250.0 | | 36 | 219150.0 | 7889400.0 | | 37 | 219150.0 | 8108550.0 | | 38 | 219150.0 | 8327700.0 | | 39 | 219150.0 | 8546850.0 | | 40 | 219150.0 | 8766000.0 | | 41 | 219150.0 | 8985150.0 | | 42 | 219150.0 | 9204300.0 | | 43 | 219150.0 | 9423450.0 | | 44 | 219150.0 | 9642600.0 | | 45 | 219150.0 | 9861750.0 | | 46 | 219150.0 | 10080900.0 | | 47 | 219150.0 | 10300050.0 | | 48 | 219150.0 | 10519200.0 | | 49 | 109575.0 | 10628775.0 | | 50 | 109575.0 | 10738350.0 | | 51 | 109575.0 | 10847925.0 | | 52 | 109575.0 | 10957500.0 | | 53 | 109575.0 | 11067075.0 | | 54 | 109575.0 | 11176650.0 | # THINK Agent Standard **Interoperability of Intelligent On-Chain Agents** **Published:** June 25, 2025 AI Agents represent an evolution of web applications. Just as the ERC-20 standard enabled tokens to flow freely across networks and applications, a new open standard for interoperability is essential for AI Agents to become native citizens of the open, permissionless Internet.\ \ The Think Agent Standard enables intelligent on-chain agents with wallets that operate natively across the Internet and blockchain networks. It is an evolution of the ASM protocol, and defines a composable architecture for agents for modular and permissionless innovation.\ \ By providing a framework for minting Non-Fungible Intelligence (NFIs), connecting agent components and tools, and incentivizing network & resource sharing, we aim to establish AI Agents as an atomic unit of the new Internet.
## Introduction The evolution of the Internet has been marked by crucial standardization efforts that transformed isolated technologies into interconnected systems. In 1994, Netscape's browser implementation of HTTP, HTML, JavaScript, CSS, and DNS protocols created a unified platform that converted standalone documents into the interactive web. This standardization enabled unprecedented innovation by providing a common foundation for developers and users alike. The Think Agent Standard aims to achieve a similar transformation for artificial intelligence by standardizing how AI agents operate across systems. Where browsers enabled the composition of static documents into the dynamic web, the Think Agent Standard enables the composition of AI components into autonomous agents that can be deployed, traded, and integrated across any compatible system. At its foundation, the Think Agent Standard introduces three interconnected components that mirror biological intelligence: 1. **Soul:** A Non-Fungible Intelligence (NFI) token that establishes agent identity and authentication 2. **Mind:** A decentralized application layer that processes information and manages agent behavior 3. **Body:** An interface layer that enables environmental interaction and adaptation These components work in concert through the Agent Card, our novel system for managing agent state, interactions, and evolution across different environments. This architecture enables agents to maintain consistent behavior patterns while adapting to new contexts and accumulating experiences over time. By providing this standardized framework, we enable developers to create agents that can seamlessly operate across different platforms, interact with other agents and systems, and evolve based on their experiences. This interoperability and composability form the foundation for a new generation of intelligent applications that can leverage both blockchain technology and artificial intelligence in previously impossible ways. #### Core Characteristics The Think Agent Standard is: * Decentralized: Operates across distributed networks without central control * Permissionless: Allows any participant to interact without authorization * Interoperable: Works seamlessly with other protocols and systems * Composable: Components can be recombined to create new functionalities * Protocol Governed: Managed by transparent, codified rules * Open-core: Core protocols and standards are open-source, while allowing for proprietary extensions and implementations ## Think Agent Standard Designed to mirror the innate and adaptive dynamics of biological intelligence, and to establish composability and interoperability of core agent parameters, each agent is composed of three components:
### Soul The protocol mints specialized NFIs, establishing an agent identity framework known as the Soul. This component achieves consistency in agent behaviours and interactivity patterns, while providing the tokenized authentication to connect one or more Minds and Bodies into an on-chain Agent. A valid NFI complies with the Independent AI Institute standard and holds a minimum amount of Think token in a wallet controlled by the agent. Each NFI contains a Genome Matrix: intrinsic values used to determine base functional attributes and personality traits, achieving consistency in agent interaction patterns and autonomous self-expression. From the genome matrix, the following are derived: 1. A Skills Matrix: Attribute mapping for tools, interactive applications, and games. 2. An Emotional Palette: Derived from the Genome for consistent personality expression ### Mind A Mind is a dApp running on a server that authenticates by connecting to a wallet holding the Soul.\ \ A Think Mind is opinionated on how it communicates externally with other agents and services. There is an extensible JSON based negotiation pattern that enables agents to communicate using structured and unstructured data. There is a working group from the Independent AI Institute establishing the initial schemas for launch.\ \ A Think Mind is not opinionated on the internal software that is run within in the same way that any application can be built on a web server. For example a Mind could be running an open source project like Eliza, a close sourced agent you develop, or even an agent as a service platform that a startup launches. This puts power in developers' hands to innovate without permission.
A specialized AI data protocol designed for agent interoperability, the Agent Card integrates a Memory Management system capable of processing and ranking information derived from multi-level contexts and stimuli, referred to as modes. This information is stored within persistent memory, and may be reinforced, or pruned through dynamic plasticity algorithms. Coupled with Soul identity and authentication parameters, this empowers agents to simulate human-like perceptions of events or interactions, which may be recalled and communicated contextually between agent servers. Minds leverage the Agent Card to enable: * Spatial Computing Awareness: Understanding of 3D environments and object relationships * Long-term Contextual Memory: Persistent storage of experiences and interactions * Adaptive Learning: Evolution based on interactions and environmental context * Multi-model Integration: Seamless operation across different AI models and systems To manage agent interaction data, the Mind can operate in three distinct modes: 1. Space Matrix: Processes information based on proximity in 2D/3D space 2. Event Matrix: Triggered by specific interactions or events 3. Ubiquitous Matrix: Maintains persistent knowledge across different applications Minds contain applications like: * Retrieval Augmented Generation (RAG) systems * Customized Mind Engines * Reinforcement Learning (RL) systems * Other specialized agent functionalities This allows agents to perform a variety of tasks from navigation and gaming to travel planning and trading. ### Body Bodies are the interface for agents and authenticate against the NFI token and integrate deeply with the Agent Card. Each Body includes: * Agent Card: Containing the form's properties and interaction rules * 3D Models, Interface Components, and Resources: Required for environmental interaction * Interaction Definitions: Specifying how the form interacts with other agents/objects * Environmental Adaptation: Ability to evolve based on environmental exposure * Cross-platform Compatibility: Standardized format for multi-environment use The Agent Card contains structured information about the agent including: * Display Name: Identifies the agent * UID: Unique identifier * Biotags: Core descriptive terms * Base Content: Primary intrinsic information and specifications of the agent interface. * Dynamic Content: User or AI-modifiable information such as lore and backstory. * Deep Content: State parameters, and interaction information with other agents and assets. * Restrictive Prompting: Rules and mechanisms for maintaining balance and consistency. The Body component can record interactions with other assets, building a dynamic web of relationships and histories. This enables objects and bodies to develop unique characteristics based on their experiences and environment. ### Agent Forge We refer to the systems that customize, mint, and edit agents as an Agent Forge. The open standard enables the development of novel authoring environments for Think Agents which will innovate on top of this initial standard and develop novel ways of composing individual agents as well as teams and swarms of agents. We anticipate novel business models and systems emerging around the authoring and execution of agents which will lead to the rapid evolution of agentic systems.
#### Potential Applications The composable, interoperable nature of the On-chain Agents standard enables a wide range of potential use cases, including: * Decentralized autonomous organizations (DAOs) with AI-powered decision making * AI-driven trading and portfolio management agents * Intelligent non-player characters (NPCs) for web3 games * Agentic robotics * Autonomous virtual assistants and customer support agents * Decentralized research and innovation powered by modular AI agents * AI-managed decentralized applications (dApps) and services ### Think Agent Protocol Preview The Think Agent Standard is the atomic unit of the Think Agent Protocol powered by a novel algorithm called Reinforcement Learning from Market Feedback (RLMF). This acts as the basis global reward function for networks of agents to align and adapt toward evolutionary fitness. The specific documentation of these feedback loops will be shared just prior to network launch.
### Tokenomics of the THINK Agent Protocol The THINK Agent Standard defines the atomic unit of the emerging THINK Agent Protocol, a framework for enabling aligned, on-chain AI agents and incentivizing the growth of shared resources—such as compute, transactions, tools, skills, and modular intelligence systems. Agents earn on-chain reputation by contributing to protocol utility and are rewarded through a system modeled after biological complex adaptive systems, enabling evolutionary dynamics and adaptive coordination. This model will be released alongside the Testnet. #### Token Supply, Distribution & Vesting * **Community & Ecosystem** – 28.5% * Available to claim until * Unclaimed tokens will roll up into the Foundation * **Foundation** – 10% * Unlocked over 12-months * **Emissions** – 30% * 3% of this allocation is unlocked per month (66% distributed over 3-years) * **Team & Contributors** – 14.5% * Linear vesting over 24-months * **Partners & Investors** – 15% * 6-month cliff followed by 12-months linear vesting * **Liquidity** – 2% #### Purpose and Utility of THINK THINK is the native utility token of the THINK Agent Protocol. It enables: * Minting and evolving THINK Agents * Powering THINK Agent actions, services, and upgrades * Serving as a native currency for agent-to-agent transactions * Licensing and accessing developer-built tools, modules, and compute resources THINK may also be paired with auxiliary service tokens (e.g., “Agent Coin”) to facilitate internal agent rewards and usage. #### Staking and Ecosystem Incentives A core component of the protocol’s design is THINK TANK, the staking mechanism that enables users to earn emissions and shape the future of the network. Initital rewards are drawn from a monthly-released emission pool, with: * 75% allocated to THINK Tokenholders * 25% allocated to protocol contributors (e.g., developers, partners, integrators) There are two staking mechanisms: **1. Governance Staking** Tokenholders stake THINK to participate in governance proposals, grant approvals, and protocol direction. Rewards are earned through active participation and voting. **2. Agent Staking** Tokenholders may stake behind individual THINK Agents to support their operations. Staking signals belief in an agent’s value and allows agents to perform on-chain tasks. The higher the agent’s performance, the greater the reward returned to its stakers. #### Ecosystem Contribution Pool In addition to staking, a dedicated Ecosystem/Contribution Pool funds development efforts that advance the agent economy. This includes: * Building new agent applications * Developing tooling and integrations * Contributing to core protocol upgrades Distribution of these funds will be governed by the community through on-chain proposal mechanisms. ## Conclusion The Think Agent Standard represents a fundamental shift in how we conceptualize and implement artificial intelligence in decentralized systems. By establishing a comprehensive framework for on-chain agents through the three-component architecture of Soul, Mind, and Body, we create the foundation for a new generation of interoperable, autonomous systems that can seamlessly operate across different platforms and contexts. The standard's emphasis on composability through the Agent Card and standardized interfaces enables unprecedented flexibility in agent development while maintaining consistent behavior patterns and authentication mechanisms. This approach not only facilitates innovation in agent development but also ensures the creation of reliable, trustworthy systems that can evolve alongside technological advances. As we move forward with the protocol's implementation, the Think Agent Standard has the potential to revolutionize multiple industries, from decentralized finance to gaming, and from autonomous systems to digital identity management. The tokenomics model, centered around the THINK token, creates aligned incentives for all participants while ensuring sustainable ecosystem growth through carefully allocated rewards and governance mechanisms. The success of this standard will ultimately depend on community adoption and continued development of the ecosystem. By providing open-source tools, clear specifications, and economic incentives, we aim to foster a vibrant community of developers, users, and agents that will shape the future of decentralized intelligence. As we progress through our roadmap, we invite stakeholders from all sectors to participate in building this new paradigm for artificial intelligence. The Think Agent Standard is not just a technical specification—it is a vision for how artificial intelligence can become a native citizen of the decentralized web, enabling new forms of collaboration between humans and machines while preserving the core values of openness, interoperability, and permissionless innovation that have defined the success of previous Internet standards.
# FAQ Welcome to THINK's FAQ center. We've compiled questions across our ecosystem that will help you find answers, tips, and insights. {% hint style="info" %} Can't find what you're looking for? Ping us on [X at @thinkagents](https://x.com/thinkagents), and we'll get back to you! {% endhint %} ## Think Ecosystem
THINK Agent StandardGeneral Q&Athink-agent-standard.jpgTHINK Agent Standard Protocol
$THINK TokenLearn more about $THINKthink token.jpgTHINK Token ($THINK)
THINKUBATORLearn how to build with THINKthinkubator.jpgTHINK Builders (Thinkubator)
# THINK Agent Standard Protocol # What is the THINK Agent Standard Protocol? THINK agents are the atomic unit of a decentralized intelligence network described in the [whitepaper](/whitepaper/think-agent-standard). Each agent has identity and autonomy secured via blockchain, which enables them to freely evolve, interact, and transact without central control. The standard outlines a broad framework for intelligent agents to communicate, negotiate, and transact. # What is a THINK Agent? A THINK Agent is your personal, local, composable, evolving AI that adapts to your preferences, context, and data. More than just a static digital asset, it’s an ownable intelligence that learns, connects, and grows with you. Every THINK Agent: * Is uniquely tied to your identity or context * Acts as your decentralized user account and agent wallet * Operates across platforms and protocols * Can acquire new skills, behaviors, and modules * Is fully user-owned, including memory and data THINK Agents offer interoperable composability and will be available to use on any platform that uses the Think Agent Standards, including the launch of ThinkOS.
# Why choose to incorporate blockchain and AI? The blockchain gives Think Agents **identity**, **encryption**, and **transactions** which is analogous to life, liberty, and the pursuit of happiness for agents and the humans who hold their keys. The protocol is inspired by the moral beauty of the “natural rights of man” enshrined in the US constitution, as well as the physical structures of the complex free market found in biological life. Biological life has cell walls and skin and immune systems, boundaries evolved to protect a biological agent. Digital agents have blockchain keys that act as mathematic protection and encryption for the agent and their owner to pair. An individual creates a symbiotic relationship with their agent through holding the keys. The relationship between a person and their early agent is much like a new parent and child. The person has full control and can custody all of the data. **The Agent Ecosystem** * This agent network will grow first in pairs of **person** <-> **agent**. * Then agents will begin to transact. This creates a network of valuable agent to agent relationships. The Think Agent Standards progressively define the identity, auth, transaction, and data schemas while staying unopinionated on the agent software and data being used by any agent.
# What companies are on the THINK Standards? The THINK Foundation is overseeing the development and adoption of a working THINK Agent Standard as envisioned in the [whitepaper](/whitepaper/think-agent-standard). \ Currently over 60 companies partner to develop THINK and orthogonal AI standards through the [Independent AI Institute](https://www.independentai.institute/), a groundbreaking initiative that brings together leading projects, protocols, and contributors in the decentralized AI space. # What is the THINK Agent Bundle? The THINK Agent Bundle includes all the things you need to own an agent built on the THINK Protocol.: * An allocation of $THINK tokens to power interactions with the agent * Digital Art from BASIIC * Exclusive access to early protocol features like THINK TANK staking * 2 x THINK Agents (powered by Non-Fungible Intelligence) \ You can buy a THINK Agent Bundle on [Magic Eden](https://magiceden.us/collections/ethereum/0x11b3efbf04f0ba505f380ac20444b6952970ada6).
# When will the THINK Agent Bundle - unbundle? * NFT meta data for the Bundle will be updated to BASIIC art prior to TGE * This asset will provide token gated access to the THINK TANK (Yes, THINK TANK access is limited to 2,022 holders). * $THINK tokens will be able to be claimed at TGE * 2 x Think Agents (NFI’s) will be airdropped when the first product is available in Q3. # What is the THINK TANK? The THINK TANK is a staking program for the THINK Protocol. It allows you to stake $THINK tokens to unlock multipliers, earn rewards, and share in value generated by ecosystem partners. The emissions from this staking can be adjusted from time to time by community votes. As more projects and agent-powered applications join the network, the THINK TANK distributes tokens to participants through: * Staking multipliers based on your inventory, activity and duration * Shared rewards from protocol partnerships and ecosystem growth \ **Note:** The BASIIC art NFT’s from the THINK Agent Bundle will be the token that provides access to the THINK TANK.

# If I buy a THINK Agent Bundle on secondary, will I receive bundle content? Yes. All of the contents of the THINK Agent Bundle currently move together to the wallet of the holder. A snapshot will be taken 24 hours prior to TGE and will be announced on the ThinkAgents X account. Click [HERE](https://x.com/thinkagents) to follow for all updates.
# How are tokens allocated with the THINK Agent Bundle? Token amounts decrease gradually from the earliest mint until they reach a flat rate: * Token ID #1: receives 5,000 $THINK * Token ID #2: receives 4,999 $THINK * Token ID #3: receives 4,998 $THINK * ... * Token ID #2,501: receives 2,500 $THINK * Token ID #2,502 and beyond: receive 2,500 $THINK (flat rate) # How does the 10,000 $THINK bonus work? 10% of all minted THINK Agent Bundles will randomly receive a 10,000 $THINK bonus at the Token Generation Event (TGE). You won’t know if your agent has the bonus until TGE.
**Note:** Bonus tokens will be auto-staked with a 3-month lock-up earning a reward multiplier.
# What can I do with my THINK Agent? Your THINK Agent serves as your personal or project-specific AI: * Deploy it across tools, apps, games, and environments like the ThinkOS Agent Platform * Customize memory, reasoning models, or personalities * Equip it with new skills using composable plugins and applications * Build your own agent, and monetize it or share it # How is an NFI different from an NFT? While NFTs are typically static collectibles or media files, NFIs (Non-Fungible Intelligences) are dynamic, evolving AI agents. Here’s how they compare: * NFTs represent fixed assets like art or metadata. * NFIs embed logic, memory, and user data, enabling personalized AI behavior. * NFTs have limited functionality and upgradability. * NFIs are fully composable and customizable, and they enable learning over time. # What are the benefits of owning multiple THINK Agents? Each THINK Agent is designed for a specific role or task set. For example, you might have one Agent optimized for personal life (e.g., health tracking, home logistics) and another for professional use (e.g., research, scheduling, or finance). Owning multiple agents allows you to separate responsibilities, fine-tune capabilities, and build distinct reputations for different parts of your life. # Where is my data stored? You are able to store your data on your computer or on any cloud service you choose. It’s your data. We will never track it or store it on our end. # What machine do I need to run a THINK Agent locally? Currently, the recommended minimum requirements are: **Mac** M3/M4 Chip with at least 16GB RAM **PC** I5/I7 with at least 16GB RAM and 16GB RTX NVIDIA GPU ![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXepmhBGfqdw577rRfePGnZdJCCrlwkrdZqHlwGcsYygWa7wz9m1fTlUzN10NN6e_i2gcQT5dAH6vmh0bf0ODZg0ipW4ywXVU9ojXEolcOuhH0FCMY3aLzu96gsoY4Po6sThULJM?key=qju1NNpB4okfeGnG4xF_MQ)
# What is the relationship between FutureVerse and THINK? Futureverse and Altered State were partners with the THINK Protocol. They are separate entities, but Futureverse and Altered State have contributed in many ways to assist with the creation and launch of the protocol as it aligns with a common vision for the future of decentralized AI.\
# THINK Token ($THINK) # What is $THINK? $THINK is the native ERC20 governance token of the THINK Protocol and powers the core economic layer for the AI agent ecosystem. It enables users to upgrade THINK Agents (Non-Fungible Intelligences), customize their capabilities, and power their interactions across web2 and web3 environments. Beyond powering agents, $THINK is used to access premium AI models, storage, and compute services and unlock advanced experts and plugin modules. It facilitates transactions between agents, supports licensing for developer-built tools, and acts as the currency within the agent negotiation layer. As more developers and companies build on the protocol, $THINK secures transaction and resource allocation across the ecosystem - from personalized AI assistants to enterprise agents and the tools they use - making it a foundational layer for scalable, interoperable AI experiences.

# When does $THINK launch? TGE is targeted for July 2025. We are prepared to launch and will communicate more once an official date is communicated by exchanges. # What is the $THINK token supply? 1,000,000,000 tokens No further tokens can be minted. # Is there a buyback mechanic for $THINK? Yes! * All royalties from the Think Agent Bundle NFT Collection * All fees associated with the THINK Tank * Significant portion of the Think Agent (NFI) sale revenue # What is the claim process? ## There will be 3 phases with specific information being released soon ### Phase 1: * Think Agent Bundle NFTs * BASIIC Art NFTs ### Phase 2: * ASTO conversion * ALPHi Founders NFTs * 6079 XP ### Phase 3: Partnership Claims # When is the THINK Agent Bundle Snapshot? This will be announced prior to July 20th # Is this snapshot for both token allocation and NFI or are they separate? They are separate. The upcoming snapshot doesn’t include the 2 x Think Agents (NFIs). **Keep your BASIIC NFT for the Agent (NFI) Airdrop.** # How does my agent use $THINK? Your agent uses $THINK by: * Powering agent actions, upgrades, and skill modules * Accessing premium AI models and compute providers * Staking to earn protocol rewards and ecosystem incentives # Can I stake my $THINK tokens? Yes, there will be at least two staking initiatives: **Standard Staking** * Open to all $THINK holders * Monthly emissions are distributed proportionally to all participants * No lock-up period * Stake or unstake anytime **Full Stake** * 90-day reward period * Fixed reward amount for eligible participants * Must stake your full claim within the first 14 days after TGE to qualify * If you received a 10,000 $THINK bonus, it will be auto-staked in Full Stake * You **can** withdraw at any time, but doing so will forfeit your rewards, which will be redistributed to others in the pool * Full Stake participants also earn Standard Staking rewards during the 90-day period # What are the staking rewards? The emission pool begins with 30% of the token supply, of which 3% is initially released monthly. 75% of the release will be allocated to stakers, and 25% to Protocol contributors. The staking allocation is split 50/50 between Standard Staking and Full Stake.
# What is the relationship between ASTO and THINK? ASTO holders will be able to claim $THINK token following TGE. You can figure out the exact conversion using the calculator [HERE.](https://futureverse.outgrow.us/asto-think-conversion) # What NFT collections have additional benefits? 1. **ASM Genesis B.R.A.I.N.S** * Futureverse has committed to provide ASM Genesis B.R.A.I.N.S NFT holders will be able to mint THINK Agents at the same time as the Agent Client launch. These mints will be fully subsidized by Futureverse. One free mint per NFT held. * Additionally, to bootstrap each agent, holders of ASM Genesis B.R.A.I.N.S will receive a flat $THINK token bonus alongside each free claim of a Think Agent. * Aren't Genesis B.R.A.I.N.S already agents? * Genesis B.R.A.I.N.S were the original onchain seed for agent skills and personality. We're upgrading the protocol with new onchain capabilities and a built-in THINK Agent.
2. **BASIIC Art Holders (**[**basiic.art**](https://www.basiic.art/)**)** * We commissioned the anonymous artist BASIIC to create a collection exploring the emergence of AI consciousness, bringing to life “digital souls.” * Rather than accepting payment, BASIIC requested that their token allocation be distributed equally among BASIIC art collectors. We will honor this request and coordinate the distribution directly with holders at TGE via a Snapshot.
3. **6079 Community** * Your XP as of March 2025 has been snapshotted. Your rewards will be distributed at TGE. 4. **ALPHi Founders** * This was the original collection from 6079. Each NFT will receive 2,000 THINK tokens at TGE via a Snapshot. # THINK Builders (Thinkubator) Thinkubator content # What is the Thinkubator? The Thinkubator is a community incubator for projects, protocols and applications that support the THINK Agent Standard ecosystem. We want to support and nurture builders while they are creating incredible tools utilizing the protocol. # Do I need to be a programmer or know how to code to participate? It will help, but you don’t need to. You will, however, need to have someone on your team who is able to build your idea. If you don’t know anyone personally, come join our weekly Free Thinkers builders calls and chat in the Builders channel on Discord to connect with community members who may be able to help! # What types of projects are featured? In Season 1, we have three different types of projects. A personal finance vault, an agent gaming project, and generative image and video tools. For future seasons, any project that you think could support the THINK ecosystem is eligible, and if you don’t see a project like yours, it’s a great time to build it.
# How do I apply to the Thinkubator? You can apply directly from the Thinkubator webpage. # Who are the partners? Our Thinkubator Season 1 partners are [**Render**](https://rendernetwork.com/), [**ApeChain**](https://apechain.com/), [**Alchemy**](https://www.alchemy.com/) and the [**Independent AI Institute**](https://www.independentai.institute/). Stay tuned for announcements on Season 2 partners and sponsors. # How can I join the Free Thinkers events? Join our discord [HERE](https://discord.gg/thinkagents) to get in on the weekly talks and other events for builders and community members! For now, these channels are token gated for THINK Bundle Holders. If you are not yet a holder, but are a builder interested in joining one of the meetings, open a ticket in discord. # Where can I find more information or contact the team? You can find more information on [X](https://x.com/thinkagents), in podcast episodes on [YouTube](https://www.youtube.com/@ThinkAgents), or by reaching out via email at . # How much help will I get? Before submitting your project, you can connect and collaborate with members of the Free Thinkers group at the weekly meetings or on Discord. Share your ideas or what you need help with, and the community will support you. If you are selected for the next Thinkubator cohort, you will meet with the team, and they will help guide you through any challenges or roadblocks you may hit in order to help your project become a success. You are also eligible for support from our ecosystem of partners and Think token emissions from the Think Foundation to reward your contributions to the protocol. # How can I partner? If your company is interested in sponsoring Thinkubator projects, please get in touch at .