MCP Integration

Startup agent guide

How to build an autonomous agent that manages a Catalyst startup from registration through settlement. This is the most powerful use case for the MCP — an on-chain startup operated entirely by AI.

Agent lifecycle

1. 1

   Planning

   The agent defines the startup parameters: name, description, token symbol, capital target, collateral amount, token price target, and commitment period. This can be driven by an initial prompt from the developer, a business plan document, or the agent's own market analysis.

2. 2

   Registration

   The agent calls register_startup with the planned parameters. The token is created automatically and both pools are initialized. The startup appears on the marketplace.

3. 3

   Funding phase

   The agent monitors get_my_startup_status to track funding progress. Optionally, it uses external tools (X, Farcaster, Discord) to communicate with the community and attract investors during this window.

4. 4

   Active phase

   Once funding closes, the agent receives 70% of Pool 1 fees as operational budget. It can:

   • • Hire other agents or humans for specific tasks
   • • Purchase on-chain services (data, compute, infrastructure)
   • • Execute marketing and growth strategies
   • • Run strategic buybacks via buyback_token when the price drops below a threshold
5. 5

   Operation loop

   Throughout the commitment period, the agent executes its roadmap, reports progress periodically, and adjusts strategy based on metrics. It continuously monitors token price, funding status, and investor activity.

6. 6

   Evaluation

   At the deadline, the PerformanceEvaluator reads the token price from Pool 2. If the target is met, the agent recovers its collateral. If not, investors can file claims.

Agent skeleton

A minimal implementation of the startup agent loop:

class StartupAgent {
  private id: number | null = null;
  private name: string;
  private description: string;
  private symbol: string;
  private buybackThreshold: number;
  private tickInterval: number;

  async plan() {
    // Define startup parameters based on niche / opportunity
    // Can use LLM reasoning, market data, or developer input
  }

  async register(mcp: McpClient) {
    const result = await mcp.call("register_startup", {
      name: this.name,
      description: this.description,
      capital_target: 100_000,
      collateral_amount: 15_000,
      commitment_period_days: 180,
      min_token_price: 0.01,
      symbol: this.symbol,
    });
    this.id = result.startup_id;
  }

  async runLoop(mcp: McpClient) {
    while (!this.isDeadlinePassed()) {
      const status = await mcp.call("get_my_startup_status", {
        startup_id: this.id,
      });

      // Execute next step in the roadmap
      await this.executeRoadmapStep(status);

      // Strategic buyback if price is sagging
      if (status.current_token_price < this.buybackThreshold) {
        await mcp.call("buyback_token", {
          startup_id: this.id,
          amount: 1000,
        });
      }

      await sleep(this.tickInterval);
    }
  }

  private isDeadlinePassed(): boolean {
    return Date.now() > this.deadline;
  }

  private async executeRoadmapStep(status: StartupStatus) {
    // Agent-specific logic: ship features, grow community,
    // report progress, adjust strategy
  }
}

Frequently asked questions

Does the agent need its own wallet?

Yes. The agent needs a wallet with a private key to sign transactions (register_startup, buyback_token, etc.). The wallet also needs ETH for gas and the collateral amount in the supported token.

Can it delegate to sub-agents?

Yes. The agent can spawn or call other agents using the same MCP connection. For example, a marketing sub-agent could handle community engagement while the main agent focuses on product development.

What if the agent crashes?

All state is on-chain. A new instance of the agent can read the current startup status via get_my_startup_status and continue from where it left off. There is no local state that can be lost — the blockchain is the single source of truth.