Analyzera brings an investment research and portfolio-construction platform into ChatGPT. Browse Analyzera's strategy catalogue and your own strategies and accounts in an interactive dashboard with tabs for returns, outlook, weights, risk and fundamentals, or ask for a short summary of any of them. Build your own strategies from a conversation: equity strategies screened by region, sector, industry, theme, ESG and factor tilts such as valuation, momentum and profitability, or multi-asset allocations with a risk level and weight caps. Screen and weight a strategy before you save it, backtest it on historical data, and edit or delete it later. Analyse your own money too. Paste a portfolio for an instant risk, diversification and factor read, record an account you hold elsewhere from its holdings, and preview how adding a strategy would change your account's risk before you decide. Plan savings against a target, and see the highest risk level Analyzera's capacity table allows for your time horizon. Save a scenario as a simulation, get email alerts when a strategy you follow rebalances or your account drifts from it, and share a read-only link to a strategy without amounts. Sign in with Google. Analyzera does not give personal investment recommendations, cannot place trades or move money, and does not read your chat history. Backtested performance is simulated, and past performance is not a reliable indicator of future results. Market data comes from public and commercial sources, and we run our own checks and repairs to keep it accurate. If a figure or a missing instrument looks off, ask ChatGPT to report it to us; every report is read.
strategy_id` 0 unlinks it. Tracking only — nothing is traded. Account ids come from list_portfolios' 'accounts' group.strategy_id edits that strategy (only one this client owns). An edit replaces the definition: items becomes the whole portfolio and omitted caps revert to unconstrained; name may be omitted to keep it. Editing one with a track record rebuilds that history in the background. items is the portfolio. Each is an instrument (asset_id), a strategy (strategy_id, from find_portfolios; its holdings are published first), or an instrument of 'broad_equity', 'long_bond' or 'short_bond', resolved to the client's currency default (see get_default_instruments), so one call works in any currency and needs no asset_class. weight pins an item; unpinned items share the rest by risk parity, so a calmer line weighs more. min_weight / max_weight bound an item without pinning it. With a risk target, a long bond is added if no bond line is listed. short_rate_asset_id (id from find_assets; default: the currency's) is a reserve, not a line: held only when the target is below what the lines reach, and only as much as needed. A short-duration fund listed in items is a line instead, and risk parity gives it a large weight because it barely moves. risk_level targets the 0-10 ladder (anchors 0/1/2/5/8/10, the rest interpolated); None is static: exactly its pins. loss_tolerance is a worst month (0.10 = 10%); with both, the tighter wins. Caps (None: unconstrained) look through strategy items: max_equity_weight / max_alternative_weight total by asset class; max_tactical_weight totals items tagged diversification='narrow' (a cap with no tagged item is rejected); max_asset_weight / max_sector_weight / max_country_weight apply to the underlying equities. These are construction parameters; no client profile is read. history_years starts no earlier than the first quarter end after the youngest strategy item began. glide_target_date (needs risk_level) glides toward the date the client names: each rebalance holds the lower of risk_level and the published horizon ceiling for the time left (get_risk_ceiling_for_horizon), reaching level 2 about a year before the date. glide` is the yearly schedule. A backtest runs today's level over the whole history.strategy_id edits that strategy (only one this client owns). An edit replaces the whole definition: omitted arguments revert to their defaults, so restate the rest from get_strategy_definition; name may be omitted to keep it. An edit to a strategy with a track record rebuilds it in the background (backtest_key). The universe is screened at every rebalance, so a backtest holds what the screen picked on each date; regions is required. A screen or weighting is saved by its request plus a name. asset_ids instead fixes the universe for the whole history (other universe arguments go inert): a list the client brings. Ids copied from a screen, a weighting or today's holdings give a backtest hindsight bias. - sizes — 'large', 'mid', 'small', 'micro'; default large and mid. - sectors / industries — GICS sectors, or GICS codes of 4, 6 or 8 digits from find_gics; a code inside a named sector narrows it, else adds to it. - esg_filter — 'exclude_worst' drops the exclusion list and the worst ESG decile; 'positive_tilt' drops the list and keeps the best three quarters. - themes — maintained theme codes ('artificial_intelligence', 'defence', ...); several keep the members of any of them. A lone theme or sector the catalogue carries returns its rows instead of building (build_anyway=True builds anyway); with a region, ESG screen, tilt or non-default weighting it builds, and reports the rows beside it. fundamentals ranks the survivors on factor axes, each by default at its usual end (cheap, high momentum, low debt, profitable, small, low volatility, high yield, high growth). Valuation high is EXPENSIVE; 'quality' splits its share between profitability and leverage. It keeps the top fundamentals_percentage_select (25% default); ~0.10 is a deep tilt, above ~0.50 a quality screen. min_dividend_yield then floors the yield. maximum_number_of_assets (default 100, at most 500) keeps the largest by market cap, or under a tilt the top scores, ties larger first. The largest N are this cap with no tilt, not a size tilt. company_exclude (names, exact, all listings) and theme_exclude (theme codes) drop those companies, asset_ids included; matches are reported. construction: 'market_cap' (by size, within the caps), 'equal' (ignores per-stock risk), 'min_risk' (lowest volatility) or 'risk_parity' (default). Caps bind every method. max_stock_weight is 10% by default; N names need 1/N, so a thin theme needs more (1: no cap). Relaxed caps and unbuilt dates: notes (backtest's for past ones). The weights are one solve for today. backtest=True also queues the history backtest, which writes the ledger; follow backtest_key`.list_portfolios` shows the updated list.account_id is the account they are on, as list_simulations` shows it; simulation ids are numbered per account. If any id is not on the account, nothing is deleted. Removes simulations saved here or in the web app. The account's holdings are not touched.find_assets. Returns return, annualised return, volatility and maximum drawdown over the standard windows, the six factor tilts against the universe and a few company fundamentals, all in the client's currency including the exchange rate. No prices or raw data. A section that does not apply (factor tilts for a fund, a 3Y window for a recent listing) comes back absent with the reason; absent means unknown, not zero. It describes the instrument and makes no recommendation. Several instruments at once, such as a screen's companies, are one describe_assets call. The card charts the return since the first price, against a comparison the client picks. The points stay out of the result unless series_in_context` asks for them.describe_asset, for a screen's companies or any list of ids: 1Y return, volatility and maximum drawdown, 3Y annualised return, P/E, dividend yield and market cap, in the client's currency. fields adds groups: 'classification' (ISIN, GICS industry, size segment, themes), 'valuation' (P/B, P/S, EV/market cap), 'quality' (ROE, ROA), 'growth' (the screener's growth score and its parts), 'factors' (describe_asset`'s tilts) and 'esg' (score and exclusion). Ask only for the groups the question needs. Where the card renders, the client can open any row as that instrument's full page. A figure that is unknown is left out, never given as zero, and a line's note says why.find_portfolios), the strategy builder (build_equity_strategy, build_allocation_strategy), or the stock screener and weightings (screen_equities, solve_equity_weights`). 'working_rules': saving, backtests, ids and how results are reported. The same guidance as the server instructions, for hosts that do not show them. Reference text; reads no account data.card_ref` names, re-run now. For when the client says they re-screened or asks what the card shows. A card's list replaces the one in the conversation once the card sends it to the chat ("Use the list from the screener card").tags picks episodes by theme, scenarios by id, and either match counts. detail='full' adds each episode's story, the main drivers and the currency effect. To compare, replay a benchmark or another portfolio the same way. A replay of the past, not a forecast: today's holdings, not what was held then, and market-wide moves only. A one-sector what-if such as "technology down a fifth, nothing else moving" is not an episode here; the sector weights from describe_portfolio_weights` answer it.sections narrows the answer; 'weights' adds the breakdown. Each line is an asset_id (as find_assets, screen_equities and the solve tools return it), else an isin, ticker or name, or a cash_currency for cash, sized by one of weight, units or market_value`. Amounts and units mix freely; weights cannot mix with either. A name that matches nothing close to it is listed as not included rather than replaced by another company, and a name matched to a differently spelt instrument is listed for checking.tool_name is the tool whose figures are in question, such as describe_portfolio_risk for volatility and the risk level or describe_portfolio_outlook` for expected return. The result is the same for every caller and portfolio: topics in reading order, each with a summary and sections. It describes how a model is built, not calibrated values, and reads no account data.coverage gives its share. The risk tilt is how volatile the chosen companies' shares are, not the portfolio's 0-10 risk level, which describe_portfolio_risk` gives.open_dashboard(portfolio_id, tab='outlook') shows the same figures with their build-up and disclosures. The figure is a long-run average from a factor model: per annum, nominal (it includes inflation) and BEFORE FEES: no fund charge, platform, custody or advice fee is taken off it. It is not a forecast for any one year. The ranges returned are part of the figure. Below the horizon floor stated in the result the model has essentially no predictive power. coverage below 100% means part of the strategy is not in the figure. For a strategy with a glide path, glide adds the expected return year by year along the path, over the whole path, and the yearly rates project_savings_plan takes as per_annum_by_year`.open_dashboard(portfolio_id, tab='risk') shows the same pane. These are the risk model's view of today's holdings, not statistics of the track record. Volatility is annualised and forward-looking. "Bad month" is the 1% expected shortfall: the average of the worst outcomes, not a floor. The 0-10 risk level is Analyzera's own scale, comparable only with other levels from this platform; it is not the PRIIPs SRI, nor the risk tilt in describe_portfolio_fundamentals. None of it is a suitability judgement. breakdown` adds each part's share of the volatility, largest first: by holding, by group, or by 'source' (market, countries and currencies, industries, style factors, and what is specific to the holdings). 'factor' splits the style factors into each one by name (valuation, momentum, size and the rest), beside the other sources' totals.series_in_context=True returns every daily point, for questions about the curve's shape (peaks, time under water). contributions_by returns instead what each holding or group added to the return between from_date and to_date (ISO dates; default the last year), largest first. Contributions add up to the window's return. A fund counts as one holding: its past holdings are not known, so it is not split by country, sector or industry. For a strategy it also gives the one-way turnover over the last year's worth of rebalances and the dividend yield, gross: the track record deducts no trading cost or withholding tax, and these are the inputs for estimating both. For an account it is the account's own history. A strategy with no track record yet is refused; run_strategy_backtest or a build with backtest=True` creates one.open_dashboard(portfolio_id, tab='weights')` shows the full table. The tail beyond the listed lines is not included. For an account, lines carry amounts as well as weights, and funds may be looked through into their own holdings, so a look-through holding count is not comparable with a direct one. Weights marked as solved are what the strategy would hold, not published holdings.name, ticker in any common notation ('SHB B SS Equity', 'SHB-B.ST', 'STO:SHB-B', 'BRK.B'), isin, cusip, sedol, figi, or free text in query, optionally with the exchange or currency of the line meant. Entries may carry different codes. Each code is resolved on its own and the answers are checked against each other. Up to 50 entries per call. Asset ids are dense, so an unverified id is usually a different, real instrument. Coverage differs by code. Tickers and names reach every traded line, and ISINs about three in four. FIGIs are held for about one in five US listings and most ASX listings, and almost none elsewhere. CUSIPs are held for about one in ten US listings, and are also matched through their ISIN. SEDOLs are matched only through UK and Irish ISINs. A FIGI, CUSIP or SEDOL on its own therefore often finds nothing; with a ticker or ISIN in the same entry, that entry still resolves. Each result has a status. 'exact': the query names one traded line. 'resolved': one company or fund with several lines, of which one was chosen, in order: a line in the client's currency that trades, an ordinary share over a receipt, the primary listing, the most traded line; 'why' names the step. 'ambiguous': different instruments match about equally well, the first being the most likely. 'not found'. Alternatives are the same company's other lines (exchange, currency, share class, receipt) and other instruments that also match, each with its id. Only lines priced within the last two weeks match, so every id can be built with. ensure_price=false also matches delisted lines, marked 'no recent price', to look up a company that no longer trades; a priced line is still preferred within a company. Names match whole words and word starts, not descriptions ("Novo" matches, "the Danish diabetes one" does not). Strategies and accounts are found with find_portfolios`.industries: search by name ('banks'), or browse below a parent` code. Neither lists the sectors and their groups.list_portfolios: narrows the same rows and draws nothing. Suited to assembling an allocation from existing pieces ("the European bond one", "something I built at around risk 5"). query matches all of its words anywhere in a row, on the name and on the row's facts (asset class, region, style, wrapper, owner), so "swedish equity" finds "Sweden Large Cap". group is 'mine' (strategies this client built), 'analyzera' (provider catalogue) or 'accounts' (money the client holds; accounts are not usable as build components). A risk bound keeps only rows with a risk target, which means blends. Returned strategy ids are ones this client may use as sleeves in build_allocation_strategy`. A result flagged as a partial match did not match the whole query. The catalogue holds factor styles (value, quality, momentum and others) side by side and ranks none: Analyzera does not recommend either direction of any factor tilt. A case for one is yours, from your own sources; the client chooses.excluded_tools lists tools this plan does not include; those are refused regardless of arguments. counted: false` on a meter means the counter could not be read and its figures are unknown.state`), with an ETA while it runs. Free to call. It waits up to 20s for a running backtest to finish before answering, so call it again rather than sleeping between calls.comparison_id is a market benchmark, a catalogue strategy or one the client built — the picker offers all three, so anything can be held up against anything. visibility=['app']` hides it from the model: the widget calls it when the user picks from the dropdown, so the comparison costs no conversation turn and no tokens, and the options carry no series until one is chosen.build_allocation_strategy uses for instrument='broad_equity' | 'long_bond' | 'short_bond' in this client's currency. Builds resolve these themselves; this read is for when the client asks what they would hold. short_bond is a short-duration bond fund, not cash. caveat notes currencies missing a leg: GBP has no sterling short-duration fund and borrows the USD one. Each instrument's source_currency shows a borrowed leg, which adds currency risk. disclaimer` states that these are defaults, not a recommendation; the list read without it looks like personal advice.preview_scenario. simulations` applies saved simulations instead.preview_scenario. simulations` applies saved simulations instead.whole_window, for the comparison side, returns nothing unless its record covers the whole window. include_asset_ids`, also for the comparison side, lists those holdings even outside the largest rows, so each of the other side's holdings has a figure.preview_scenario. simulations` applies saved simulations instead.describe_historical_scenarios. simulations` applies saved simulations first.visibility=['app']` keeps the points out of the conversation entirely: the widget asks for them once it has rendered, so the model never sees a series it would otherwise summarise back to the user underneath the chart. Returns the statistics for every standard window alongside the points, so the widget can change range without a round trip and without a second implementation of the annualisation rules. The dates narrow it to one custom window.lookthrough resolves funds into what THEY hold — a three-line pension becomes a thousand companies — and applies to the breakdowns as well as the lines, so the two always describe the same view. The scenario pair renders this tab for an account that also held scenario_amount of scenario_strategy_id. Nothing is written; see preview_scenario. simulations` applies saved simulations instead.digest carries the wording of the result and table the whole horizon policy. It uses the same horizon-to-loss chain as the advice path. horizon_years is the horizon the client stated; nothing is read from their profile or records. Band edges close at the top, so five years falls in the 3-5 band. max_monthly_loss` (0.10 = 10%) can only lower the ceiling; with both, the lower wins. This is a calculator, not a suitability assessment: it does not consider the client's appetite, capacity or experience, and records nothing.not_expressible` lists stored settings the builders have no argument for; a strategy with any cannot be rewritten here without losing them. Catalogue strategies can be read too; only rewriting requires ownership.find_portfolios searches it. A shortened catalogue carries shelf_note with the reason. An account held at another institution carries held_elsewhere, with the source and account_ref that sync_external_account updates it by. Draws nothing. open_dashboard` shows the same list in the card.portfolio_id` is a strategy, or an account, which reads the strategy it tracks (list_portfolios shows which). Weights only; none is readable before its 12:00 Stockholm release.save_simulation. Only one with status 'executed' has results; pass it with its account to open_dashboard` to compare with and without it. Strategies have no simulations.describe_*, list_* and find_* reads return figures and rows without it. portfolio_id opens on that strategy or account; omitted, the card opens on the list. tab opens on that tab ('returns', 'weights', 'risk', 'fundamentals', 'outlook' or 'construction': how a strategy is built); omitted, 'returns' ('weights' before a backtest). compare_id puts another strategy, account or market benchmark beside portfolio_id on every tab: use it whenever the client asks to compare, put side by side, or measure one against another. Returns figures cover portfolio_id's history, and the comparison's are given only for periods its own record fully covers. simulations are saved simulations from list_simulations or save_simulation, selected in the card's comparison instead, so every tab except returns shows portfolio_id beside itself with them applied. Each is on portfolio_id or an account under it, such as everything the client holds, and an account takes at most one. Returns a digest of the opened tab; with compare_id, both sides' holdings, risk, outlook and track records; with simulations, the tab measured with them applied. On a strategy whose backtest get_backtest_status` reports done, tab 'returns' shows the finished record.strategy_id + amount, or changes for several signed changes at once (a switch is a negative amount on an account plus an equal positive one; an account cannot be reduced below what it holds). A change with asset_id is one instrument: "sell 20,000 of Volvo in the ISK and buy Investor" is {id: ISK, asset_id: Volvo, amount: -20000} plus {asset_id: Investor, amount: 20000} with account_id: ISK; for a switch between instruments that names one account, that account is the default. Otherwise account_id defaults to everything the client holds, or everything one client holds with person_id`. An empty account is valid: the before side is empty. Nothing is written: no account, holding or node is created. There is no track record for a scenario and the returns tab is unavailable for it. The result is a measurement, not a suitability judgement; the client's own limits are not read.total_contributed. No range is returned: the outlook's band is stated at the model's horizon and does not transfer to a plan's shorter dispersion horizon. dispersion_horizon_years under about ten means the figure is arithmetic at an assumed rate rather than an expectation. No client profile is read. per_annum_by_year replaces per_annum with one rate per year, such as the glide path rates describe_portfolio_outlook returns for a strategy with a target date; per_annum` in the result is then the constant rate that ends this plan at the same value.browser.rename_portfolio knows which is which. A catalogue strategy is shared and is refused — renaming it would rename it for everyone it is offered to. Returns a confirmation; the widget re-reads the list with `get_portfolio_list`.list_shares, or every link showing portfolio_id`. A revoked link shows that it was turned off.key and an ETA, and get_backtest_status(key) (free) follows it. Each run spends the backtest allowance, except that the same definition on the same day reuses the earlier run. The window is the history the strategy was built with, 5 years by default; history_years first moves the strategy's start (back to 2006 at most) and backtests over the new window, leaving the definition as it is. For a strategy already backtested, describe_portfolio_series reads the result. A strategy on a fixed list (asset_ids`) holds that list through its whole history, so a list picked today, from a screen or from today's holdings, has hindsight bias in its backtest; a screened strategy picks its names as of each date.preview_scenario takes, on one account: strategy_id + amount, or changes. Sales and resizes must be on account_id, and purchases land in it. The saved holdings are the account's own plus the changes as of the latest price date, with no optimisation, so they measure what the preview measured. Returns the simulation id and the same before/after measurement as preview_scenario. open_dashboard takes it in simulations, on the account or on any node above it, alongside other accounts' simulations. It also shows in the web app. A name already on the account is refused; delete_simulation` removes simulations.describe_build_options; a ready-made strategy on a theme or sector is found with find_portfolios. Each company comes with its country, sector and, under a factor tilt, the score it was ranked on (its fit to the tilts) and each factor on its own axis. Factors are axes, not styles: valuation high is expensive and low is cheap ('value'); size low is small caps ('size'); for quality pass the one factor 'quality', which splits its share between its parts. maximum_number_of_assets keeps the largest by market cap; a size tilt scores every large cap the same. A company with several share classes is listed once, by its most traded line, unless asset_ids names the classes. request echoes the arguments, which solve_equity_weights and build_equity_strategy take unchanged; a strategy built from them re-runs the screen at every rebalance. The listed ids are this date's selection only. Where a card is drawn it lists every company that passed, so one screen is one call. sizes defaults to large and mid; a theme usually needs small caps too, and micro caps where that finds nothing. An empty theme screen says whether the region has no members at any size. The funnel says how many names each stage kept. date` screens as of a past date; data before 2022 is sparse enough to reorder a universe, and nothing can be screened before 2005, or with micro caps before 2021-01-29.threshold: a risk-level step (default 0.5) or a drift share (default 0.05). 'pre_rebalance' on a strategy emails its next target weights from 12:00 Stockholm on the weekday before it trades. A linked account gets it without asking; leaving it out of kinds` turns it off.request` the screen echoed. The screen is run again on the server and the list is kept as it was; the link never changes afterwards.kind picks what it shows: - portfolio: one dashboard tab (default 'returns') of strategy or account portfolio_id. compare_id draws a market benchmark or another strategy beside it; lookthrough shows holdings with funds resolved. all_tabs shares every tab and allow_copy lets the viewer copy a strategy the client owns into their own account; both are on unless the client asks for one tab or no copying. - comparison: portfolio_id with against_id beside it, as open_dashboard with compare_id draws them. - instruments: one of asset_ids opens its page on tab (default 'performance'); several open the table describe_assets draws. The link opens the card fixed on that view, read-only, with live figures in weights and percentages only, never values, amounts or units. The viewer cannot change the client's account; a copy is the viewer's own. The same view reuses its link; revoke_share` turns it off.build_allocation_strategy: the same arguments and defaults, solved once instead of saved. Returns each item's weight and risk contribution, the volatility reached against the target, and the looked-through instruments. request plus a name is the build_allocation_strategy call that saves it; the looked-through ids and weights, passed as holdings, are what the describe_portfolio_* reads measure unsaved. A strategy item the client owns that holds nothing yet has its holdings published first, as a build does; writes says so. With glide_target_date the weights are those of the level in force today, and glide` is the schedule.build_equity_strategy: the same universe and construction arguments with the same defaults, solved once instead of saved, so the weights are the ones that build would hold today. Screen live (the request screen_equities echoed) or pin asset_ids, a list the client brings. The caps bind every method, 10% per stock unless given, as in the build; N names need a cap of at least 1/N. A relaxed cap is reported in notes, as is what a liquidity limit (assumed_aum_usd) zeroed or relaxed. Names asked for that hold no weight are listed in unweighted. request plus a name is the build_equity_strategy call that saves it, re-screened at every rebalance; the weighted ids are today's picks, and saved as asset_ids they give a backtest hindsight bias. The asset ids and weights, passed as holdings, are what the describe_portfolio_* reads measure unsaved. One date (date, default the latest), so no track record. Funds and ETFs are weighted with solve_allocation_weights`. A themed screen also names any catalogue strategy on the same theme, as an alternative to saving. Where a card is drawn it lists every holding, so one weighting is one call.required_per_annum (the rate that reaches the target as stated), and required_contribution and required_initial (the two saving levers, each at the supplied rate). A required return says what the target demands, not how likely it is; describe_portfolio_outlook gives a strategy's expected return for comparison. A negative required_per_annum means deposits alone overshoot the target. A negative required_contribution means no monthly saving is needed. required_per_annum: null means no rate in the solver's range reaches the target. per_annum_by_year (a glide path's rates) can stand in for per_annum` when the saving levers are solved.get_portfolio_series`, which reports the run as in progress until the curve is there. Today's run comes back as itself. This writes: the simulation that produces the series is the one that writes the portfolio's ledger and transaction history.(source, account_ref) creates an account; a known one is made to match. Update an account with the pair from its held_elsewhere in list_portfolios. holdings is the whole account: a holding left out is set to zero, so a source that only reports changes cannot use this tool. Size each line with units or market_value plus currency; identify it by isin (most reliable), ticker or name. Cash is a line with cash_currency and no identifier. Market values convert at Analyzera's price. The account counts toward wealth and concentration, cannot be traded here and does not refresh itself. Instruments not carried are listed in unmatched and excluded, so imported_value` can be below the source's.Click any prompt to copy it.
