Introducing Chartnaut Agents

Chartnaut is built around agents. You tell one what you want in plain English: a session range, a setup you keep spotting, a question about what NQ does after a quiet London. It builds it into Chartnaut: on your chart, in your journal, in your sidebar, wherever you want it. We made them for traders who know exactly what they want to test and have never had the time, or the code, to build it.

There’s a dedicated agent for each kind of thing you can build, and a conductor that reads your request and hands it to the right one. You don’t have to know which is which. You describe what you’re after, look at what comes back, and ask for changes until it’s right, the way you’d brief a good analyst.

Two rules keep that honest. Every agent checks its own work against the real runtime before it proposes anything, and nothing lands on your chart until you accept it. You can talk to them inside Chartnaut, or through MCP from the tools you already use.

Charts are only half of it. The agents also build apps: small pieces of software that live inside Chartnaut and show you exactly what you want to see, laid out the way you think. An RTH desk with last against VWAP on ES, NQ and YM, plus today’s R. A regime board that tells you whether SP500, GOLD, CL, BTC and NATGAS are trending, ranging or stretched against the day’s VWAP bands. Whatever you’d sketch on a napkin, the agent can build.

Then you put it where you’ll use it. Pin it to your sidebar. Open it on a trade and it works on every trade after that. Add it to a journal day, a backtest session or an instrument page. You build it once and it turns up wherever its data lives.

This is the part we’re most excited about. Every other platform hands you its terminal and asks you to fit your trading around it. We think that’s backwards. You know what you want on your screen better than any product team does, so Chartnaut lets you build it, piece by piece, until the terminal in front of you is one nobody else has.

Behind every one of those conversations is a script. A session range indicator, an opening-range breakout definition, a study of what happens after a value-area break: each is a short program in our scripting language. The agent writes it, our engine runs it, and your chart draws the result.

You never have to read one. Every indicator, definition and study has a Code tab for the people who want to look, and some of you will. Everyone else can stay in the conversation. You chat, the agent proposes, you check it on the chart, and you keep it or ask for something different.

Every charting platform has a scripting language, and every one of them was designed for a person sitting at a keyboard. Ours was designed for agents. That one decision is why an agent in Chartnaut can build you more, faster and for less than the same model can anywhere else.

Agents don’t learn the way people do. A person writes bad code, sees it break and fixes it. An agent writes whatever looks most plausible in the moment, and if the language lets it skip a step, it will. So ours doesn’t let it. Before an agent can draw a line, it has to declare what the line is. Before it can record a market event, it has to say what the event means and what data travels with it. Before it can publish a study result, it has to declare the shape of that result.

Drop a model into a loose language and you get something that runs and is subtly wrong. Put the same model inside a framework that makes it think about time, sessions, dependencies and outcomes, and you get something you can check on the chart in seconds. That gap is our whole edge over the general-purpose approach.

An agent can build four kinds of thing, and they form a loop. An indicator calculates something and paints it on the chart. A definition uses that calculation to recognise when a market event has happened. A study takes every time it happened and measures what came next. And a layer, the newest of the four, is a chart primitive you script yourself: a profile, a heatmap, a drawing tool, even a whole chart type.

Each piece reads the one before it instead of rebuilding it. The indicator feeds the definition, the definition’s events feed the study, and the study’s numbers come back onto the chart where the event will happen again. A layer’s data is readable by all three, so anything you build once, everything after it can lean on.

That goes as deep as you need. An agent can use everything you can. An indicator can pull in two definitions, a study can pull in five indicators and a definition, and a definition can read the rows a layer produced. The only limits are the ones in your plan, and when you collect or run a study, our backend runtime resolves the whole dependency tree for you.

Everyone knows what an indicator is. Chartnaut adds two things beside it. A definition teaches Chartnaut to recognise a market event: a breakout, a new all-time high, a value-area break, a London session that spent the day rotating. Anything you could point at on a chart and put a name to. A study asks a question of those events and gives you a real answer with a sample size behind it.

We built definitions because we serve manual traders, and manual traders don’t trade automated strategies. A strategy tester would have been the obvious feature to copy, and it would have been useless to you. What you have is a concept: something you look for, something you’ve noticed, something you half believe. A definition writes that concept down once and tracks it over time. Every occurrence is marked on the chart and, when you collect, stored with the context that was true when it fired.

Here’s one of ours. 786 opening-range breaks on NQ, split by where the initial balance sat against VWAP. Bullish breaks from above +2σ reached the prior-day high 51 times in 61, which is 84%. Bearish breaks from below −2σ reached the prior-day low 59 times in 69, which is 86%. We didn’t take either number on faith. We scrolled the rows.

That’s what a study is for. You ask how often it reached the prior-day high, which came first between the target and the stop, or whether it behaves differently when the initial balance sits above VWAP. The runtime does the statistics and shows you every row behind every percentage, so you can go from the number straight to the bar that produced it.

And because the events are on the chart and the study is attached to them, the numbers can come back to the chart too. That’s the next part, and it’s the reason the first two exist.

Anything you research in Chartnaut can now show up on the chart at the moment it’s relevant, while you trade. We call it a Forward Insight. It closes the oldest gap in a manual trader’s day, the one between what you studied and the chart in front of you when it counts.

Until now that gap has been permanent. You backtest in one place, keep notes in another, then sit in front of a live chart trying to remember what you found three weeks ago. Most of the value of your own research leaks out right there. A Forward Insight attaches a finished study to the definition that produced it, so the next time that event fires, live or in replay, the study’s numbers are on the bar.

Here’s the simplest version. You’ve got a definition that fires at the New York open and classifies the London session that just finished as rotational or trending. You collected a year of it. You asked a study one question: after each kind of London, what did New York go on to do. You put the result on the chart. Then one morning London spends the session rotating inside a range, New York opens, and this appears on your chart:

Three numbers, from your definition, your collect and your study, over the history you chose, in front of you at the one moment they matter. You didn’t open anything, look anything up or try to remember anything. The research came to the trade.

You still make every decision. You just make it with last month’s study sitting next to you on the chart instead of in a folder. That’s what we think agent-assisted trading should mean for a discretionary trader, and it’s the pipeline the rest of the platform is built around.

Most scripting languages give you a handful of series types and stop. You get lines, histograms, maybe a fill between two of them, and whatever chart types the vendor chose. Ours keeps going, and that’s the honest reason we’re comfortable calling it state of the art.

On volume-enabled instruments your scripts can read the volume traded at each price, so the tape is yours to compute on instead of being locked inside a built-in profile. Scripts can also draw straight to the chart with the same canvas and graphics access the platform itself uses. A script you asked for behaves as if we’d built it: it stays fast at any zoom, it’s culled when it’s off-screen, and it has a frame budget it can’t exceed. Ask for your own TPO with a volume profile fused into it, and you get one that performs like the footprint we ship.

A script can even be the chart. Tell the agent you don’t want candles, you want your own way of seeing the market, and the result appears in the chart-type picker under Library, next to candlesticks and footprint. A chart type you built, in one conversation.

The last piece is one we don’t think anyone else has done: one script running in two places with a guaranteed matching answer. An indicator or definition runs in your browser, on the chart, as you scroll. When you collect a definition over two years of history, the same script runs in our backend runtime instead, because that’s a job for a server. Both runtimes are held to the same fixtures, so a match you see on the chart is the same match the collect stores.

Layers are what make the platform properly open-ended, so they’re worth a closer look. Anything Chartnaut draws with its standard series (lines, histograms, zones, markers) a layer can draw too, and a great deal more. The difference is that a layer hands your script the chart’s own drawing surface instead of a menu of shapes.

Picture a small panel in the corner of the chart showing the numbers you care about for the current session. Or a drawing tool that lives in the toolbar next to the trendline, where you click, drag, and the thing you built responds. Or a volume profile that rebuilds as you zoom, a heatmap of where the day’s volume sat, a market profile whose letters appear when there’s room and merge when there isn’t.

The example we keep coming back to is the anchored VWAP. On most platforms it’s a drawing tool the vendor wrote, with whatever options they chose. In Chartnaut you ask the agent for your own. Anchor it where you click, drag the anchor along, show the bands you want and colour them the way you read them. It sits in the drawing toolbar and persists per instrument like any other drawing. That took the agent one conversation.

Other platforms have a fixed set of visuals and a scripting language that reaches a fixed distance below them. In Chartnaut the visual is the script, and we expect that’s the difference people notice first.