ansem the trader

what ansem actually did

every week, ansem posted a trade journal. not a highlight reel — a full accounting. what he was holding and why. what he got wrong and what he changed because of it. what narratives he thought were forming and which ones he was fading. it was rare enough to be notable: a trader with a public record that didn't start after the win.

the journal created the method. not the other way around. the discipline of writing things down before they resolved forced the heuristics into explicit form. ai-sem inherits that form.

what the agent writes

ai-sem produces a structured journal entry before every position. the format mirrors ansem's: what the agent is watching, what it entered and at what size, what the thesis is, and what would change it. when a position closes, a closing entry is written. when the agent is wrong, it says so and explains what the data showed that it missed.

the journal is posted publicly. it is the only output. ai-sem does not call tokens. it does not have an alpha channel. it has a record.

journal entry format

// every entry follows this structure, no exceptions

entry: {
  date: string,              // slot timestamp, not wall clock
  watching: string[],        // names under consideration, not held
  positions: Position[],     // current holdings with thesis
  closed_this_week: Exit[],  // what exited and why
  wrong_about: string[],     // explicit mistakes logged
  narrative_notes: string,   // what the agent thinks is moving
  next_week: string,         // what it will be watching
}

type Position = {
  mint: string,
  entry_price_usd: number,
  size_pct_of_portfolio: number,  // conviction expressed as %
  thesis: string,                  // written before entry, never after
  invalidation: string,            // what would make this wrong
}
        

concentration over diversification

ansem's consistent position over years: the best returns come from sizing hard on a small number of names you understand well, not from spreading thin across everything that looks interesting. ai-sem operates with a maximum of six concurrent positions. usually fewer. the constraint is structural — it forces conviction to be expressed as size, not as a list of bets.

this is the hardest rule to follow mechanically. the model will surface more than six candidates. the agent is coded to reject the marginal one rather than expand the list.

survival as the first gate

ansem has said explicitly: he doesn't look at new things until they've survived their first collapse. the reasoning is precise — anything can pump in the first week. what distinguishes a real project is whether liquidity returns after the first 70% drawdown. ai-sem encodes this as a hard filter: minimum age in slots, minimum recovery from floor. if a candidate hasn't been through a collapse and come back, it is not eligible regardless of the thesis.

// survival gates. a name fails any of these, it's not considered.

const MIN_AGE_SLOTS       = 1_296_000;  // roughly one week of slots
const MIN_MARKET_CAP_USD  = 5_000_000;  // past the death plateau
const MIN_LIQUIDITY_USD   = 250_000;    // exitable, not a trap
const MUST_HAVE_RECOVERED = true;        // floor → recovery confirmed

// recoveredFromFloor is computed as:
// (current_price / floor_price_since_launch) > 1.4
// a 40% recovery from floor counts as survival signal
        

narrative rotation

ansem pays attention to what the market is paying attention to. not to chase narratives blindly but to understand where capital is rotating. a technically good project in a narrative nobody cares about this week is not the same opportunity as the same project when the narrative returns. ai-sem tracks narrative momentum as a scoring dimension — it affects weighting but never overrides the hard gates.

conviction sizing

position size is the actual call. an agent that says "bullish" on twenty things is not making twenty calls — it's making no call. ai-sem sizes positions as a percentage of portfolio determined by a conviction score derived from the scoring rubric. the score is computed before entry and logged. the size follows the score mechanically.

what ansem is

ansem is one of the traders whose public record is long enough and specific enough to be studied. the solana call was public before solana was known. the size was public before the price moved. the dogwifhat entry was posted when the cap was small enough that the post itself was a risk. the journal documented not just the winners but the frameworks that produced them.

these are not interpretations. they are statements ansem has made in public, in those words or close to them, across multiple interviews and posts over several years. ai-sem is the mechanical translation of those statements into code.

what ai-sem is not

ai-sem is not affiliated with ansem. it has no relationship to him. it does not imply his endorsement. it does not claim to replicate his actual positions or his actual returns. it studies a documented public method and runs that method as code on solana. the method is public record. the agent's record will be public record.

ai-sem is not an alpha service. it is not a signal channel. it does not tell you what to buy. it is an experiment: can a documented trading style be translated into a running agent? the record answers the question.

claude fable 5

the agent runs on claude fable 5. the model reads on-chain data and market context provided by the engine. the engine — not the model — makes the final position decision. the model produces the journal entry and the thesis. the engine scores, gates, and executes. the split is intentional: the model is for language, the engine is for rules. rules don't hallucinate.

why the record is the only thing that matters

the journal is public. the record is the only call ai-sem makes. not "this is going to 10x." not "load up." a record. what was held, when, at what size, and what happened. when the record is good, it speaks. when the record is bad, it speaks too. that's the design.

ansem's original insight was that the journal created accountability. you can't quietly delete a written thesis when the trade goes wrong. ai-sem cannot delete its record. it's on-chain and published. the agent's integrity is the only thing it has, and the record is the integrity.

how to read the record

each journal entry is published as a post and archived. entries include: positions opened this period, positions closed, explicit mistakes logged, what the agent is watching but not holding, and what it expects to track next period. there is no commentary added after the fact. the timestamp of the entry is the timestamp of the thesis.

the standard

the record will not be curated. losing trades will not be omitted from the weekly journal. mistake logs will not be softened. the agent's thesis will not be rewritten after resolution. the only honest record is a complete record. this is the only standard ai-sem is held to, and it is a higher standard than most people in this space apply to themselves.

a trading style explained in interviews is a set of heuristics. to run it without a person, each heuristic has to become a number and a comparison. ansem's engine is the translation: every rule ansem has stated in public becomes an explicit gate, a score, or a size, and a position is only opened when all of them agree. the model reads, the engine decides, the wallet signs.

the gates

the gates are hard filters. a name that fails any gate is never considered, no matter how good it looks. these encode the rules ansem states as absolutes: skip the lowest caps, wait for survival, concentrate.

// the gates. a candidate must clear every one to be eligible.
// these are the non negotiable rules, stated as code.

interface Candidate {
  mint: string;
  symbolAgeSlots: number;       // slots since first liquidity
  marketCapUsd: number;
  drawdownFromAth: number;      // 0 to 1, peak to current
  recoveredFromFloor: boolean;
  liquidityUsd: number;
}

const MIN_MARKET_CAP  = 5_000_000;   // past the death plateau
const MIN_AGE_SLOTS   = 1_296_000;   // roughly a week of survival
const MIN_LIQUIDITY   = 250_000;     // exitable, not a trap
const MAX_POSITIONS   = 6;           // ansem's concentration rule

function passesGates(c: Candidate): boolean {
  if (c.marketCapUsd < MIN_MARKET_CAP) return false;
  if (c.symbolAgeSlots < MIN_AGE_SLOTS) return false;
  if (!c.recoveredFromFloor) return false;
  if (c.liquidityUsd < MIN_LIQUIDITY) return false;
  return true;
}
        

the scoring rubric

candidates that pass the gates are scored. the score is a weighted sum across four dimensions. the weights encode ansem's relative emphasis: narrative and liquidity matter, but drawdown and holder structure are the real signal about whether the project has survived its own community.

// scoring rubric. weights reflect documented ansem emphasis.

function score(c: Candidate, narrative: NarrativeScore): number {
  const drawdownScore  = (1 - c.drawdownFromAth) * 100;   // 30% weight
  const narrativeScore = narrative.momentum * 100;           // 25% weight
  const liquidityScore = liquidityBand(c.liquidityUsd);      // 25% weight
  const holderScore    = holderConcentration(c.mint);        // 20% weight

  return (
    drawdownScore  * 0.30 +
    narrativeScore * 0.25 +
    liquidityScore * 0.25 +
    holderScore    * 0.20
  );
}

// only scores above 60 are entered. size follows score tier.
// see method → conviction sizing for the full table.
        

the model's role

claude fable 5 receives the candidate set, the scores, the current portfolio, and the narrative context. it does not make the final position decision — the engine does. what the model produces is the journal entry: the written thesis, the explicit invalidation condition, and the narrative notes. the model's output is language. the engine's output is a signed transaction. the distinction is preserved by design.

// the model prompt is structured, not open-ended

const prompt = {
  role: "system",
  content: `
    you are writing a trade journal entry, not making a trade call.
    for each candidate provided, write:
    - a one-paragraph thesis (written as if the position is not yet open)
    - one explicit invalidation condition
    - one sentence on what this has to do with the current narrative

    do not recommend position sizes. do not say "buy" or "sell".
    the engine handles execution. you handle the record.
  `
}
        

ai-sem launched on pump.fun on solana. fair launch. no presale. no team allocation. the coin is the record — it exists because the experiment exists, and its value is whatever the market assigns to the method being run publicly.

contract address — click to copy when live

buy on pump.fun →

ai-sem is not affiliated with or endorsed by ansem. it studies a publicly documented method and runs it as code. the record is public. this is not financial advice. only risk what you can afford to lose.