# Kestrel vs Composer: No-Code Strategy Builder vs Agentic-Trading Runtime (/blog/kestrel-vs-composer)

2026-07-12 · kestrel.markets

## Answer card

If a person wants to build a rules-based portfolio without writing code (compose conditional blocks, backtest them, and let the platform rebalance automatically), Composer is a purpose-built, well-fit tool. If the trader is an LLM that must *perceive* a live market and *act* within it in milliseconds, that shape is wrong: it assumes a human author clicking blocks and a platform holding the account. Kestrel is a language and runtime built for the other reader: the model. Different reader, different tool.

## The two products are not competing for the same seat

Composer is a no-code platform for retail investors. Its core artifact is a visual strategy, a tree of conditional logic blocks, that a person assembles, backtests against history, and then runs so the platform rebalances the positions automatically. The author is a human. The interface is a drag-and-drop canvas. The value is removing code from the path between a person and a systematic strategy.

Kestrel starts from a different premise. **The two failures of LLM trading are interface, perception and latency, not intelligence.** A frontier model can reason about a market; it cannot *see* one through a screenshot without burning a context window, and it cannot *act* on one in the milliseconds a move demands. Those are interface problems. Kestrel is the interface: a small language with four statement kinds over one lexical core, and a runtime that renders markets as text and executes contingently at machine speed.

- **VIEW** (perception): renders the market as a compact text **Frame**. **The chart is in text**: a vertical append-only tape, one row per candle, relative candles in basis points versus prior close, anchored by periodic keyframes. Perception cost is **O(new bars), not O(screen)**, KV-cache-friendly.
- **WAKE** (attention): a standing subscription over the trigger algebra. Event-driven, not polling. It spends attention (tokens, wakes), never risk.
- **PLAN** (latency): a standing, bounded-risk contingent program (trigger, actions, bracket, invalidation, TTL). The runtime fires it in milliseconds and wakes the agent in parallel. This is **fire-then-inform**: **the agent is never in the hot path.**
- **GRADE** (trust): the honest, counterfactual result of a run. Contamination-fenced: LLM authors are graded only on post-training-cutoff, date-blinded days, because **weights leak what code fences can't stop.**

The deepest split is honesty of evaluation. A no-code builder's backtest optimizes a strategy a person already designed, over history the person can see. Kestrel's GRADE scores *judgment* on days the model could not have memorized. **A backtest is never flattering** the way an honest, date-blinded grade is unflattering, and only one of those tells you whether the *agent* can trade.

## Where Composer wins, plainly

This section is not a courtesy. If the work is any of the following, choose Composer:

- **A human is the author, and the point is no code.** Composer is designed around a person assembling logic visually. Kestrel is designed around a model authoring Kestrel. If your goal is to *avoid* a language, Kestrel is the wrong direction.
- **Rules-based portfolio rotation you want run for you.** Periodic rebalancing across a basket on simple conditions is exactly the shape Composer targets, and it handles the execution and custody so you don't have to. Kestrel's model is an external agent perceiving and acting on an instrument live, not a hands-off managed rotation.
- **You want one platform to hold the account and do everything.** Composer bundles building, backtesting, and automated execution behind a single retail account. That integration is a genuine convenience Kestrel deliberately does not offer; Kestrel keeps the brain outside and takes no custody.
- **Turnkey over composable.** If you want to start investing this afternoon through one packaged product, a turnkey retail platform fits better than a language and runtime you author strategy in.

If those describe the job, stop here: Composer is the answer, and this is not a close call.

## Where Kestrel is the fit

Kestrel is the fit when the trader is a model, the edge is judgment under live conditions, and the two interface failures are what stand between the model and a market.

```kestrel
IMPORT { fade-ladder } FROM "./armory/reversion.kestrel"
USING signal SPX exec SPY 0dte

PLAN headline-chase budget 0.25R ttl 15:55 regime {intraday: trend}
  WHEN spot > hod AND velocity(5m) >= p95
  DO buy 2 +1 C @ min(fair, mid) peg cap fair
  TP 2.5x frac 0.5 @ fair
  EXIT spot < vwap held 120s @ fair
  INVALIDATE spot < hod
```

This is illustrative, with generic instruments (SPX for signal, SPY 0dte for execution), *not* a strategy recommendation. It shows how an agent *could* express a play: you deploy a template like this into your own pod and arm it; the runtime holds the contingency and fires in milliseconds if the trigger hits, and the agent is informed in parallel. Prices are expressions, not constants: `min(fair, mid) peg cap fair` composes a **VALUE** anchor with **BOOK** state and a guard, because **a quote is not a value.**

Perception and evaluation get the same first-class treatment:

```kestrel
VIEW desk budget 900
  skyline
  levels
  chain

WAKE breakout
  WHEN spot > hod
  DELIVER desk
  BUDGET 40 wakes/day

GRADE plan headline-chase OVER 2026-04..2026-06 FILL conservative
  VS null
  BY regime
```

`VS null` and `VS ungated` are counterfactuals in the syntax: the grade tells you what the judgment earned over doing nothing, and over an ungated baseline. That is a different question than "what would this backtest have returned," and it is the question that matters when the author is a model.

## Comparison table

Standardized columns. Where a Composer detail is uncertain, the cell describes the dimension honestly rather than inventing a spec.

| Dimension | Composer | Kestrel + kestrel.markets |
| --- | --- | --- |
| Primary reader | Retail human (no-code visual builder) | An LLM (authors + reads Kestrel) |
| Perception model | Visual logic blocks + historical backtest curves | VIEW → text **Frame**; streaming tape; **the chart is in text**; **O(new bars) not O(screen)** |
| Agent in the hot path? | N/A; platform engine evaluates + rebalances on its schedule | No; **fire-then-inform**; **the agent is never in the hot path** |
| Latency floor | Rebalance-oriented (periodic), not sub-second contingent execution | Runtime fires PLANs in milliseconds; agent notified in parallel |
| Native interface / MCP | Consumer web app; API/MCP surface, if any, is not the primary product | **Four equal faces**: HTTP+SSE canonical; TypeScript SDK, CLI, MCP as thin equal projections |
| Agent-native auth (Envelope) | Human account credentials | **Envelope** {scope, budget, ceiling, expiry, revocation}; two-signer; authority only narrows downward |
| Machine payment | Human billing (subscription) | Agent wallet via Stripe MPP / x402, or claim-and-fund by a human |
| Evaluation honesty | Backtest over visible history (author sees the data) | **GRADE**: contamination-fenced, date-blinded, post-cutoff; **a backtest is never flattering** |
| Provenance | Backtest reports, in-app performance history | Certified **Blotters** (deterministic Episode records), Grades, shareable **Proof URL** |
| Live model (custody) | Custodies customer accounts through its own brokerage, per Composer's public materials | **Certification over custody**: BYO broker via OAuth, no custody; **the live singleton** (one live run per pod lineage) |
| Data licensing | Platform-provided market data (platform terms) | Platform-owned Databento served as **derived works** (never raw redistribution) + BYO Alpaca |
| Activation path | Sign up → fund a brokerage account → build → auto-invest | **Proof-before-account**: trial capability → free SIM → certified proof → 402 offer only at a paid boundary |
| Pricing | Subscription tiers | Free discovery/SIM; paid boundaries surfaced as HTTP 402 offers; hosts scarcity, not the brain |
| Best for | Retail humans who want no-code, hands-off rules-based rotation | An external agent perceiving/acting live; judgment graded honestly; agent-native auth + payment |

## Status, honestly

Composer ships today as a retail product. Kestrel is the OSS language and runtime; **kestrel.markets** is the commercial platform, the Vercel to Kestrel's Next.js. Anonymous trial sims, certified Grades, shareable proof URLs, and 402 Offers run today; the free tier needs no signup. **Host the scarcity, rent the genius** is the thesis: the scarcity is capital, licensed data, latency, deterministic execution, and provenance; the brain stays outside (**the external-agent invariant**). This is illustrative and impersonal, not investment advice.

## Bottom line

These tools answer different questions. Composer answers "how do I build and run a rules-based portfolio without writing code?", and answers it well, for a person. Kestrel answers "can this model see the market cheaply, act on it in time, and be graded on judgment it couldn't have memorized?" Pick by your reader.

**Composer removes the code between a person and a strategy; Kestrel removes the interface failures, perception and latency, between a model and a market.**