We've already written about what Project Cortex is and how its agents are organized. This post is different. This one walks through how a decision actually gets made — the full path from "should we even be trading today" to "here's the ticket, does the human approve" — and how OpenClaw sessions and Obsidian memory make sure the system learns from what it does.

If you're evaluating multi-agent trading systems, or thinking about applying agent architectures to other high-stakes workflows, this is the post that shows the machinery.

The Question Clients Actually Ask: Who Decides the Trade?

When CTOs and portfolio managers first see a multi-agent system, the question is always the same: who decides?

The honest answer is that nobody decides alone. Not one model, not one agent, and not one human sitting in a chair watching a dashboard. Project Cortex is built so that a trade can only happen when multiple independent checks agree — and a human confirms.

Think of it less like a single brain picking stocks and more like a disciplined investment process that happens to run on private AI trading agents instead of a floor full of analysts. The agents are specialists. They each see a slice. The decision stack is what holds them together.

Cortex in One Sentence: Weather, Then Neighborhood, Then Name, Then Human Yes

Here's the entire decision flow compressed:

  1. Macro and liquidity set the weather. Go, sit, or go smaller.
  2. Sector scoring identifies the neighborhood. Where are we allowed to shop?
  3. Name underwriting asks five hard questions. Is this specific name worth a ticket?
  4. Rails check constraints. Commodity confirms, size caps, calendar risks.
  5. Human approves. Auto-fire is off. The system recommends; a person acts.

Every layer is a filter. Most days, most names don't survive the stack. That's the point. An honest empty day — no trades — is a feature, not a bug.

How a Buy Is Born

Step 1: Macro and Liquidity — The Weather Report

Before Cortex looks at a single name, it reads the weather. This means macro conditions and liquidity signals: calendar events (FOMC, CPI, opex), broad market internals, and regime indicators.

The output is simple: go, sit, or go smaller. This step doesn't pick a sector. It doesn't pick a name. It just decides whether today is a day to be active at all, and at what size.

Sit days are real. If the macro weather says sit, the entire stack below it stays dormant. No amount of exciting chart setups overrides a sit signal.

Step 2: Hit Sector — The Neighborhood

If the weather says go, the system identifies which sectors qualify as "hit" sectors. There are two doors into a hit:

  • Desk/CIO full view — a qualitative, top-down read from the CIO synthesis agent based on compiled research and current positioning.
  • Measured tape score — a quantitative score on sector ETFs using monthly trend with a confirming weekly signal.

A sector can be in one of several states: hit, heat-only, hold, or off. Only hit sectors are neighborhoods where the system is allowed to shop for names.

This is an important distinction: a hit sector is not a buy list. It's permission to look. Most names inside a hit sector will still fail the underwriting step.

Step 3: Name Underwriting — Five Questions

Once a sector is hit, the research and underwriting agents evaluate individual names against five specific questions:

  1. Universe permission. Is this name in our approved universe? We define the universe upfront — it's not everything that trades.
  2. Vehicle and thesis. Is this a clean vehicle for the thesis? Pure-play exposure to the sector trend, not a conglomerate where the signal gets diluted across twelve business lines.
  3. Relative strength vs. sector ETF and peers. Is this name outperforming its own sector? We want leaders, not laggards hoping for a bounce.
  4. Reclaim if faded. Has the name pulled back and reclaimed a level, or is this the first green candle off a low? First green is not a buy. We want confirmation that a reclaim is holding.
  5. Candidate news and calendar. Are there earnings inside the expected hold window? Is there a known print or event that would force us to sit into a binary? If so, the name doesn't qualify right now.

Every question is a gate. Fail one, and the name doesn't generate a ticket. There's no override mechanism where a really exciting chart can skip the calendar check.

Step 4: Rails — The Guardrails Before a Ticket Emits

Even after a name passes all five underwriting questions, it runs through a set of rails:

  • Commodity and oil confirmation for energy-adjacent names. If the commodity itself isn't confirming, the equity thesis is incomplete.
  • Size caps. Position sizing is constrained by rules, not vibes.
  • Recommend-only mode. The system emits a recommendation. It does not auto-execute.
  • Human CEO/PM approval. A person reviews the ticket, the reasoning, and the context before anything happens.

Auto-fire is off. This is a deliberate design choice. In a human in the loop AI architecture, the system's job is to do the work of narrowing, qualifying, and documenting. The human's job is to say yes, no, or not yet.

Sit Is a Feature

We keep coming back to this because it matters. Many days, the stack produces zero tickets. The weather is wrong, or the sectors aren't hit, or the names inside hit sectors fail underwriting, or the calendar is too crowded.

That's fine. A system that forces trades to justify its own existence is a system that will lose money. Cortex is designed to be comfortable doing nothing.

How a Sell Is Born

Exits follow their own logic, and they're just as structured as entries.

Time Box and Max Hold

Every position has a defined hold window. This isn't "hold forever until it works." If the thesis hasn't played out within the time box, the position is flagged for exit regardless of whether it's up or down. Time is a risk, and Cortex treats it that way.

Thesis Break

If the reason for the trade stops being true — the sector loses its hit status, the name loses relative strength, the commodity confirmation reverses — the exit process begins. The system doesn't wait for a stop-loss to get hit if the thesis itself is broken.

Risk Rails

Hard stops and risk limits exist independently of thesis evaluation. If a position hits a predefined risk level, the exit recommendation fires.

Human Still Owns Flatten

Just like entries, the human makes the final call on exits. The system flags, recommends, and documents. The person acts. This is especially true for full flatten decisions — closing everything and going to cash. That's a human call.

The Agents: Specialists, Not One Omniscient Bot

Project Cortex doesn't run on a single model pretending to know everything. It runs on a team of specialist agents, each with a defined role and bounded authority:

  • CIO Agent — Synthesizes macro, sector, and positioning data into a go/sit/smaller read. Owns the top-of-stack weather call.
  • Monitor Agent — Watches infrastructure health: are data feeds live, are sessions running, are heartbeats normal? This agent doesn't trade. It makes sure the system is healthy enough to trade.
  • Engineer Agent — Writes and modifies code, but only with approval. No autonomous deployments.
  • Execution and Risk Agent — Handles sizing, stop placement, and abort logic. Enforces rails.
  • Research Specialists — Separate agents for macro research, sector analysis, event calendars, and earnings data. Each produces artifacts, not chat messages.
  • Learning and Retro Agent — Reviews completed trades. Did the thesis play out? Was the entry timing right? Tags outcomes by sleeve.
  • Product Manager Agent — Checks whether the origin path — from weather to neighborhood to name to ticket — is clean and complete. If the path has gaps or skipped steps, the ticket doesn't emit.

Humans approve all consequential actions. Agents can research, analyze, draft, and recommend. They can't execute on their own.

How Cortex Remembers: Daily Notes, Standing Rules, Obsidian, and OpenClaw Sessions

Memory is where most multi-agent systems fall apart. Chat history is unreliable. Context windows overflow. Agents forget what they decided yesterday.

Cortex solves this with two interlocking systems.

OpenClaw: The Orchestration Layer

OpenClaw is the agent runtime. It manages sessions, skills, and heartbeats across the agent team. When the CIO agent produces a morning weather read, OpenClaw ensures that read is available to downstream agents in the correct session context. When the Monitor agent detects a data feed issue, OpenClaw routes that alert to the right agents and logs it.

OpenClaw sessions are the connective tissue. They ensure agents aren't operating on stale context or talking past each other. Every agent interaction is tracked, timestamped, and retrievable.

Obsidian: The Compiled Knowledge Vault

Obsidian is where long-term memory lives. It's a structured vault of:

  • Standing rules — persistent constraints that don't change day to day. Universe definitions, size limits, sector classification logic, risk parameters.
  • Agent notes — observations and analysis artifacts produced by specialist agents, organized by date and topic.
  • Research cards — structured summaries of sector theses, name-level analysis, and event calendars.
  • Retro findings — lessons from the learning agent, tagged and indexed.

The key design principle: artifacts and files beat chat folklore. If something matters, it's a document in Obsidian, not a message buried in a conversation thread. Daily logs capture what happened today. Standing rules capture what's always true. The two don't get confused.

This separation — OpenClaw for live orchestration, Obsidian for compiled knowledge — means agents can start a new session and immediately access everything they need without replaying thousands of chat messages.

How Cortex Learns: Tag Every Ticket, Score by Sleeve, One Friday Lesson

Learning in a multi-agent trading system isn't about retraining a model on last week's price data. It's about structured retrospection on process.

Tag Every Ticket by Sleeve

Every trade ticket is tagged with its origin sleeve — which sector thesis, which entry pattern, which macro regime. This lets the learning agent evaluate performance by strategy type, not just in aggregate.

A system that's winning on sector momentum trades but losing on mean-reversion setups needs to know that. Aggregate P&L hides the signal.

Score Sleeves Separately

Each sleeve gets its own scorecard. Did the thesis play out? Was the timing right? Did the exit happen for the right reason? This isn't just win/loss — it's process quality.

One Friday Lesson, Maximum

Every week, the learning agent produces at most one actionable lesson. Not ten. Not a wall of observations. One thing to change or reinforce.

That lesson is written into Obsidian as a standing note and obeyed at the next relevant entry. This prevents the system from over-fitting to recent noise while still adapting to genuine process improvements.

Models: Proprietary Plus Open Source, Specialist Not One Brain

Cortex doesn't run on a single model. It uses a mix of proprietary frontier models and open-source, self-hosted models, routed by the type of work:

  • Judgment calls — complex synthesis, thesis evaluation, CIO-level reads — route to frontier models with strong reasoning capabilities.
  • Classification and tagging — sector scoring, calendar parsing, data extraction — route to smaller, faster models where speed and cost matter more than deep reasoning.
  • Local and private tasks — anything touching sensitive position data or proprietary rules runs on self-hosted models inside the controlled environment.

A second model is sometimes used as a spot-check — an independent review of a recommendation to catch errors or blind spots. But it's a check, not a vote. Two models agreeing doesn't create a trade that the decision stack didn't produce. And two models disagreeing doesn't block a trade that the stack did produce. The stack is the authority. Models are tools within it.

The principle: process plus live data beats swapping narrators. Switching to a newer model doesn't fix a broken process. A sound process works across model generations.

Where It Runs: Private Servers, Data Stays in the Stack

Project Cortex runs on private servers in a controlled environment. No shared cloud tenancy. No data leaving the perimeter for model inference unless explicitly approved.

This matters for two reasons:

  1. Regulatory exposure. Trading data, position data, and strategy logic are sensitive. Sending them to third-party inference endpoints creates compliance risk that's hard to quantify and harder to remediate.
  2. Operational control. When your agent runtime depends on external API availability, you've outsourced your uptime. Private hosting means the Monitor agent can actually guarantee the infrastructure it's monitoring.

OpenClaw sessions, Obsidian vaults, model weights, and all intermediate artifacts live inside the stack. The audit trail is complete and self-contained.

What Llama Research Actually Sells From This Proving Ground

Let's be direct about what Project Cortex is and isn't.

It is a proving ground — an alpha-stage system where Llama Research tests the architecture, discipline, and tooling required for multi-agent decision-making in a high-stakes domain.

It is not a finished hedge-fund product. We don't claim guaranteed alpha. We don't sell trade signals. We don't publish a track record and invite you to subscribe.

What we do sell is the discipline underneath it:

  • Role separation — agents with bounded authority, not one god-model.
  • Audit trails — every decision documented, every gate logged.
  • Refusal capability — the system is designed to say no, and to be comfortable saying nothing.
  • Private hosting — data stays where you control it.
  • OpenClaw + Obsidian memory architecture — live orchestration paired with compiled knowledge, applicable to any domain where decisions need context and continuity.
  • Human in the loop at every consequential step — not as theater, but as architecture.

This same architecture works for regulatory review pipelines, procurement approvals in government, clinical decision support in healthcare, and any workflow where the cost of a bad decision is high and the audit requirement is real.

If you're building something that needs to make structured, defensible, auditable decisions with AI agents — and you need it to run on your infrastructure, not someone else's — that's the conversation we want to have.

Project Cortex is in alpha. Llama Research is a Toronto-based AI consulting firm specializing in private AI deployment, agent systems, and governance for regulated industries. Get in touch if you're building something that can't afford to be careless.