vAST

viaNexus Agentic Service Technology

vAST is the agent-ready access layer for viaNexus financial data. It connects MCP clients, Financial Chat Agent, and SDK workflows to 30+ institutional datasets through one signed credential, with server-side dataset permissions built in.

vAST MT Newswires News Aiera Transcripts BMLL Pre-trade ExtractAlpha EPS forecasts IndexOne Indices viaNexus CORE Reference data DATA PROVIDERS Trader Claude · MCP Analyst ChatGPT · MCP Retail investor OpenBB · Chat Agent Portfolio mgr Cursor · MCP Developer Your app · SDK DATA CONSUMERS

one platform · every dataset · any agent

Works with leading LLM providers

Gemini Gemini
Claude Claude
ChatGPT ChatGPT

About

30+ vendors.
One agent.

Financial agents need more than an API key. They need licensed data, normalized rows, and permissions that hold up across every tool call.

The problem

Agent access breaks in three places.

  1. Vendor sprawl

    Thirty vendor contracts.

    News, fundamentals, transcripts, market data, reference data. Every provider has a different API, a different auth, a different invoice. Your agent has to talk to all of them.

  2. Entitlements

    Entitlements at the row level.

    User A pays for European market data, user B doesn’t. Same agent, same query, different rows allowed. If the agent sees data the user can’t use, you’re in violation.

  3. Machine auth

    Auth that LLMs understand.

    API keys leak, hardcoded tokens expire, OAuth-for-humans doesn’t fit machines. Agents need credentials they can present, refresh, and scope without a human in the loop.

Financial data is fragmented across providers, subscriptions, and auth models. Before an agent can answer safely, it has to know which data exists, which rows a user is allowed to see, and which credential it can present.

What vAST changes

viaNexus becomes the data layer.

viaNexus provides the financial data: bundled NexusCore datasets, premium NexusEdge partner data, and provider access behind one account. vAST is the agent access layer on top, so every client uses the same catalog, auth, and dataset permissions.

  1. Data provider

    Normalized market data, fundamentals, news, transcripts, reference data, and partner datasets.

  2. Permissions

    Software statements and tokens enforce which datasets each agent or user can reach.

  3. Interfaces

    MCP, Financial Chat Agent, and SDK all reach the same allowed data through different calling styles.

MCP service

MCP
service.

Drop the endpoint into Claude, Cursor, ChatGPT, or your own app. The agent gets search and fetch wired to your subscribed datasets.

Quickstart

There are two MCP endpoints, depending on what data you need. Both authenticate against the same viaNexus account.

viaNexus MCP Universal connector setup Full catalog connector for Claude.
01 Step 01
Add the custom connector

Open Claude → CustomizeConnectors → click +Add custom connector. Paste the viaNexus endpoint and click Add.

Endpoint

https://vast.blueskyapi.com/vianexus/mcp
02 Step 02
Click Connect, sign in

Find viaNexus MCP in the Not connected list and click Connect. The OAuth popup opens. Sign in with your viaNexus email + password.

That’s it. You’re done.

Signed in successfully? You’re connected. Skip ahead to step 05 to start asking.

Need ideas? Try a pre-built Claude skill or watch a demo.

No account yet? Click Sign up, then continue to step 03.

Hitting issues? Reach out to us.

03 Step 03 New users only
Sign up, create your account

Click Sign up on the OAuth popup. Fill in your details and click Create your account.

04 Step 04 New users only
Pick a plan or trial

After creating your account, the OAuth popup hands off to a subscriptions page. Start the free trial or pick the plan and datasets you want for this connector. Existing users with an active subscription can skip this step; otherwise add datasets in the console.

05 Step 05
Start asking questions

New chat → +Connectors → toggle viaNexus MCP on. Claude now has access to whatever your subscription includes, nothing more, nothing less.

Want more datasets? Browse the full catalog and add subscriptions in your viaNexus console or jump to the catalog section.

MT Newswires MCP News connector setup News-only connector for Claude.
01 Step 01
Add the MT Newswires connector

In Claude: CustomizeConnectorsBrowse connectors. Search for MT Newswires and add it.

02 Step 02
Sign in

Adding the connector in step 01 takes you straight to the OAuth popup, no extra Connect click. Sign in with your viaNexus email + password.

Signed in successfully? You’re connected. Skip ahead to step 05 to ask for the news.

Need ideas? Try a pre-built Claude skill or watch a demo.

No account yet? Click Sign up, then continue to step 03.

03 Step 03 New users only
Create your account

Fill in your details and click Create your account. Skip this step if you signed in with an existing viaNexus account.

04 Step 04 New users only
Pick a plan or trial

Choose a viaNexus plan or continue on the free trial. Skip this step if you signed in and already have an active subscription.

05 Step 05
Ask for the news

New chat → +Connectors → toggle MT Newswires on. Real-time North America & Global headlines, in-line.

Want more than news? Add datasets in your viaNexus console, or use the universal viaNexus connector for the full catalog.

Other clients

Coming Soon

Cursor marketplace

One-click install for the viaNexus connector, bring-your-own API key.

Notify me →

Coming Soon

OpenAI / ChatGPT

Same endpoint, same datasets. MCP support for the OpenAI platform is in active development.

Notify me →

Any MCP client

Zed, custom apps

Anything that speaks MCP. Paste the viaNexus endpoint and handle OAuth via your client’s connector config.

Read the docs →

Security

Lock
and key.

One signed credential starts the OAuth flow. Every access method uses the same token introspection and dataset-permission checks: MCP, Chat Agent, SDK.

The flow

Access flow How token scope is enforced Statement, OAuth, introspection, scoped rows.

01 / 05

01 Register

Agent gets a software statement

A signed JWT issued from your viaNexus account. It identifies the OAuth client and can carry dataset permission patterns such as EDGE:MT_NEWSWIRES*.

In the hosted sign-in flow, the console creates this for you after login. In the SDK flow, you can request one with your API token and pass it to the MCP auth server during registration.

Endpoint

POST https://api.blueskyapi.com/v1/agents/register?token=$VIANEXUS_API_TOKEN
Content-Type: application/json

{
  "expiresIn": "1h",
  "permissions": {
    "include": ["EDGE:MT_NEWSWIRES*"],
    "exclude": ["CORE:*"]
  }
}

What’s in the JWT

Contact, software ID, payload ID, optional dataset permission patterns, issued-at, expiry. The API token is stored server-side for the exchange; it is not embedded in the JWT.

02 Present

Client registers, then starts OAuth

Standard OAuth 2.0 authorization code flow with PKCE. Dynamic client registration per RFC 7591 lets the client provide its software statement during registration, then continue through the normal authorize and token exchange.

Why PKCE

Protects the token exchange from interception even if the agent runs on a public client, browser, end-user device, or multi-tenant edge function.

OAuth shape

POST /register
{ "software_statement": "$VIANEXUS_JWT", ... }

GET /authorize?response_type=code
  &code_challenge=$PKCE_CHALLENGE

POST /token
grant_type=authorization_code
&code=$AUTH_CODE
&code_verifier=$PKCE_VERIFIER

RFC 7591

Dynamic client registration, no pre-registration step.

RFC 7636

PKCE binds the request to a one-time verifier.

03 Receive

Server returns a scoped access token

Short-lived. The MCP auth server stores the API-service token and dataset permission patterns with the OAuth token, then exposes them through token introspection.

When permissions are present, the MCP service filters dataset discovery and dataset fetches server-side before anything reaches the agent.

Subscription change == zero redeploy

The client can keep the same code. To change dataset access, issue a new software statement or update the subscription/permissions behind the token flow.

Token introspection payload

{
  "active": true,
  "client_id": "client_...",
  "scope": "user",
  "aud": "https://vast.blueskyapi.com/vianexus/mcp",
  "api_service_token": "pk_...",
  "contact": "analyst@example.com",
  "dataset_permissions": {
    "include": ["EDGE:MT_NEWSWIRES*"]
  },
  "exp": 1746615262     // 1h TTL
}
04 Call

Agent calls the data plane with the token

MCP request, SDK call, or Financial Chat Agent invocation, all three rely on the same token introspection path. The data plane authenticates the token, reads dataset permissions, and only exposes matching datasets.

Server-side enforcement

The agent never sees a row it doesn’t have rights to. There is no client-side filter to bypass.

Allowed call

POST /mcp/tools/search
Authorization: Bearer $ACCESS_TOKEN

{ "product": "EDGE", "dataset_name": "MT_NEWSWIRES", "symbols": "AAPL" }

200 OK  → matching news rows

Out-of-scope call (refused server-side)

POST /mcp/tools/fetch
Authorization: Bearer $ACCESS_TOKEN

{ "product": "CORE", "dataset_name": "REPORTED_FINANCIALS", ... }

error"Permission denied for dataset CORE:REPORTED_FINANCIALS"
05 Refresh

Tokens expire, clients refresh

Access tokens expire after 1 hour. Refresh tokens last longer, and SDK clients handle refresh behind the scenes when the OAuth flow has issued one.

Software statements are signed, time-limited handoff artifacts. Rotate or reissue them when you want a new permission set.

Lifecycle

Software statement (JWT): signed handoff artifact, default 1-hour expiry.
Access token: 1-hour TTL, validated through introspection.
Refresh token: 30-day TTL when issued by the OAuth flow.

Rotate permissions

POST /v1/agents/register?token=$VIANEXUS_API_TOKEN

Issue a new statement with a tighter permissions object, then reconnect the client with that statement.

What vAST Enforces

Direct consequences of the auth model. Every access method inherits all three.

  1. 01

    Credentials

    No leaked credentials.

    The agent only ever holds a signed statement and a short-lived token. No API keys to leak, no rotating-secrets runbook.

  2. 02

    Permissions

    Server-side permission enforcement.

    Dataset permissions are enforced server-side by the MCP service. Change the permissions behind the statement or subscription, reconnect or refresh the client, and the agent code does not need to change.

  3. 03

    Scope

    Per-agent scoping.

    One statement per agent deployment. A news-only agent gets a news-only catalog. The agent never sees what its dataset permissions do not allow.

Financial Chat Agent

Financial
Chat Agent.

Available with pk token

Pre-built conversational agent. Powers AskNexus today. Use it with a viaNexus pk_... token, embed it in your app, or add it manually to an OpenBB workspace.

Download guide

Quickstart

A token and one endpoint. First call lands in 20-35 seconds, follow-ups in about five.

Get token

Use your viaNexus token

Create a personal API token in the console. Tokens are prefixed pk_... and are passed as ?token=.

Open console →

Call /chat

TOKEN="your-vianexus-token"
BASE="https://financial-chat-agent-857389207619.us-central1.run.app"

curl -X POST "$BASE/chat?token=$TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"message": "What is AAPL trading at right now?"}'
FCA walkthrough Call the hosted agent Token, first call, session follow-up.

01 / 03

01 ~1 min

Grab your token

Get a personal API token at console.blueskyapi.com. It starts with pk_.

Use the token as a query param on each hosted agent request.

Environment

export VIANEXUS_TOKEN="pk_..."

Token boundary

The agent can only answer from datasets your token can access.

02 ~30 sec

Make your first call

POST a message to /chat. The response includes an answer and a session_id.

Keep the session id if you want follow-up questions to share context.

Request

BASE="https://financial-chat-agent-857389207619.us-central1.run.app"

curl -X POST "$BASE/chat?token=$VIANEXUS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"message": "What is AAPL trading at right now?"}'
03 follow-up

Continue the conversation

Pass the session_id back to keep context.

Sessions expire after 1 hour of inactivity.

Follow-up

curl -X POST "$BASE/chat?token=$VIANEXUS_TOKEN&session_id=5f942fb6fadf4791bc7dece76d4a7332" \
  -H "Content-Type: application/json" \
  -d '{"message": "How does that compare to its 52-week high?"}'

Capabilities

Platform-embeddable

Drop into any app, terminal, or workspace.

MCP-native

Speaks directly to the viaNexus MCP.

Entitlement-aware

Dataset permissions are enforced through the same MCP token flow.

Metered & billable

Per-conversation billing, marketplace-ready.

Token Access

Financial Chat Agent uses the same viaNexus account token and dataset permissions as the rest of vAST. If your pk_... token can reach a dataset, the agent can use it.

Permission flow
  1. 01

    Token
    Account and subscribed datasets.

  2. 02

    /chat
    Question arrives with ?token=.

  3. 03

    Answer
    Only allowed datasets.

Same permission model

The agent does not bypass subscriptions. It can only answer from datasets your token is allowed to access.

Get a token →
OpenBB Workspace install Chat, charts, and alerts inside OpenBB.
01

OpenBB

Manual install

Add Financial Chat Agent manually to an OpenBB workspace. Users get conversational access to 30+ institutional datasets, with charts, alerts, and tables rendered alongside OpenBB’s native widgets. The marketplace listing is MCP-only for now; the full agent is available today via manual install.

Watch demo

Conversational portfolio analysis. Natural language across every subscribed dataset, in one chat.

Dynamic chart creation. Charts and dashboards generated on demand inside OpenBB widgets.

Automated monitoring & alerting. Set alerts on any condition; data payloads delivered to email.

Entitlement-aware. The agent uses the same MCP token and dataset-permission enforcement as the connector.

Chatbot App or portal embed Hosted financial chat for your users.
02

Chatbot

Drop Financial Chat Agent into your app, portal, or website as a chat interface. Users type questions, the agent queries your viaNexus data and responds with structured answers, tables, and charts. AskNexus is the live working example, that’s exactly this use case, built and running today.

Try AskNexus

See vianexus.com/asknexus for the working consumer chat we run on Financial Chat Agent. The same agent, with the same auth and dataset-permission model, embedded against the full viaNexus catalog. Build the same thing in your product.

Agent SDK

Agent
SDK.

Open-source Python framework. Bring your LLM, bring your infra, write your code. MIT-licensed, Python 3.11+.

viaNexus-agent-sdk-python Open source · MIT

Unified factory for OpenAI, Anthropic, and Gemini. Built-in memory stores, persistent MCP sessions, automatic tool integration with the viaNexus MCP, OAuth + software-statement auth, full type hints.

Open on GitHub

Quickstart

Install via pip or uv. The factory auto-detects the LLM provider from your model name, so you can switch providers by changing one config value.

Install

# with uv (recommended)
uv add git+https://github.com/blueskynexus/viaNexus-agent-sdk-python --tag v1.0.0-pre14

# or with pip
pip install git+https://github.com/blueskynexus/viaNexus-agent-sdk-python@v1.0.0-pre14

Quickstart

from vianexus_agent_sdk.clients.llm_client_factory import LLMClientFactory

config = {
    "LLM_MODEL": "gpt-4o-mini",
    "LLM_API_KEY": os.getenv("OPENAI_API_KEY"),
    "agentServers": {
        "viaNexus": {
            "server_url": "https://vast-mcp.blueskyapi.com",
            "server_port": 443,
            "software_statement": os.getenv("VIANEXUS_JWT"),
        }
    },
}

client = LLMClientFactory.create_client(config)
await client.initialize()
response = await client.ask_question("Get Tesla's latest earnings")
await client.cleanup()
SDK walkthrough Build a news agent Register, install, ask, verify permissions.

01 / 05

01 ~2 min

Register a software statement

From your viaNexus account, request a software statement with the dataset patterns this agent can reach. For a news agent, include EDGE:MT_NEWSWIRES*.

The API returns a signed JWT. The SDK presents that JWT during MCP OAuth registration, and the MCP server enforces those permissions server-side.

Request

curl -X POST "https://api.blueskyapi.com/v1/agents/register?token=$VIANEXUS_API_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{"expiresIn":"1h",
           "permissions":{"include":["EDGE:MT_NEWSWIRES*"]}}'

Response

{
  "success": true,
  "softwareStatement": "eyJhbGciOiJSUzI1NiIs..."
}

Save it as VIANEXUS_JWT in your env.

02 ~1 min

Install the SDK

One install pulls the framework, the MCP client, and the OAuth handler. No additional setup, no separate auth library.

Python 3.11+. We recommend uv for speed, but pip works just as well.

Recommended

uv add git+https://github.com/blueskynexus/viaNexus-agent-sdk-python \
   --tag v1.0.0-pre14

Or with pip

pip install git+https://github.com/blueskynexus/viaNexus-agent-sdk-python@v1.0.0-pre14

What You Get

LLMClientFactory, persistent MCP session manager, OAuth handler, three memory backends, full type hints.

03 ~3 min

Wire the agent

One config dict. Pick a model, drop in the JWT from step 01, and let the factory wire up OAuth, MCP, and tool integration for you.

Switch providers later by changing the model name, the factory auto-detects Anthropic, OpenAI, or Google.

Auto-wired tools

The factory registers search and fetch with the LLM. Claude decides when to call them.

news_agent.py

from vianexus_agent_sdk.clients.llm_client_factory import LLMClientFactory
import os, asyncio

config = {
    "LLM_MODEL": "claude-3-5-sonnet-20241022",
    "LLM_API_KEY": os.getenv("ANTHROPIC_API_KEY"),
    "system_prompt": "You are a financial news analyst.",
    "agentServers": {
        "viaNexus": {
            "server_url": "https://vast-mcp.blueskyapi.com",
            "server_port": 443,
            "software_statement": os.getenv("VIANEXUS_JWT"),
        }
    },
}

async def main():
    client = LLMClientFactory.create_client(config)
    await client.initialize()
    answer = await client.ask_question(
        "What did Powell say about rates this week?"
    )
    print(answer)
    await client.cleanup()

asyncio.run(main())
04 ~30 sec

Run it

The SDK presents your software statement to the auth server, gets a scoped access token, opens an MCP session, and exposes search + fetch to Claude.

Claude decides when to call them. The agent loop runs until the answer is ready, then closes the session.

Run

$ python news_agent.py

What happens, in order

1.SDK presents the JWT, gets a scoped access token
2.MCP session opens, search and fetch registered with Claude
3.Claude calls search for Powell rate-related news
4.Claude calls fetch for the matching articles
5.Claude synthesizes the answer and prints it

Try the boundary

Ask about REPORTED_FINANCIALS: the MCP returns a permission error for CORE:REPORTED_FINANCIALS. Your software statement only allowed news, so the call is rejected server-side.

05 forever

Extend without redeploying

Subscribe to a fundamentals dataset later? Issue a new software statement with a broader permissions.include list.

Reconnect or refresh the client with the new statement. Code stays the same. The auth flow stays the same.

Add a dataset

Issue a new statement with broader permissions.

permissions: {
  include: [
    "EDGE:MT_NEWSWIRES*",
    "CORE:REPORTED_FINANCIALS:*"
  ]
}

Swap providers

Change one config key.

"LLM_MODEL":
  "gpt-4o-mini"
# → OpenAI auto-detected

Persist memory across runs

client = LLMClientFactory.create_client_with_memory(
    config, memory_type="file", path="./agent.db"
)

The auth flow is unchanged. New permission patterns, new providers, new memory backends, all behind the same SDK config shape.

SDK internals Runtime architecture Providers, memory, sessions, tools, methods.

LLM Providers

Three major providers, one unified interface. The factory detects the provider from the model name (or you can set it explicitly). Switching providers is a config change, no code rewrite.

OpenAI

GPT · o-series

GPT-4, GPT-4o, o1.

Detect: gpt-*, o1-*

Anthropic

Claude

3.5 Sonnet, 3 Opus, 3 Haiku.

Detect: claude-*

Google

Gemini

2.5 Flash, Pro, more.

Detect: gemini-*

Switch providers without code changes

# Auto-detect from model name
config["LLM_MODEL"] = "claude-3-5-sonnet-20241022"   # → Anthropic
config["LLM_MODEL"] = "gemini-2.5-flash"             # → Gemini
config["LLM_MODEL"] = "gpt-4o-mini"                  # → OpenAI

# Or pin explicitly
client = LLMClientFactory.create_client(config, provider="anthropic")

Memory Architecture

Three memory modes, picked per agent. Memory is session-isolated by user_id so multi-tenant deployments don’t cross-contaminate, and the same store works across all three providers.

Tier 01

Default

In-memory

Session-only. Lost on restart.

with_in_memory_store()

Tier 02

Persistent

File-based

Persists across restarts. Multi-day analyst sessions.

with_file_memory_store(path)

Tier 03

None

Stateless

No history. One-shot lookups, batch jobs.

without_memory()

Per-call memory control

response = await client.ask_question(
    "What is Apple's market cap?",
    maintain_history=True,    # keep in current session context
    use_memory=True,           # persist to / load from store
    load_from_memory=True,     # hydrate prior conversation
)

Cross-provider memory: a conversation started with Claude can be continued with GPT-4o, the store is provider-agnostic. Useful for cost optimization (cheap model for triage, premium for synthesis) without losing context.

Persistent Sessions

For long-running conversations, the persistent client keeps a single MCP session alive across many queries. The MCP handshake (discovery, registration, OAuth, introspection) happens once instead of per-request, lower latency, lower load on the auth server.

Single MCP handshake

OAuth once at session start. Tool calls reuse it.

Maintained context

Pair with file memory for multi-day sessions.

Health checks

is_connected, mcp_session_id for monitoring.

Auto-establish

auto_establish_connection=True for auto-reconnect.

Long-running portfolio session

client = LLMClientFactory.create_persistent_client(config)
await client.initialize()

session_id = await client.establish_persistent_connection()

r1 = await client.ask_with_persistent_session(
    "Analyze AAPL recent performance",
    maintain_history=True, use_memory=True,
)
r2 = await client.ask_with_persistent_session(
    "Compare it with MSFT",
    maintain_history=True, use_memory=True,
)

await client.close_persistent_connection()
await client.cleanup()

MCP Tools, Auto-Wired

No special setup. Every client created through the factory automatically registers viaNexus MCP tools (search, fetch) with the LLM. The model decides when to call them; the SDK routes calls through the MCP, applies dataset permissions, and returns structured data.

client = LLMClientFactory.create_client(config)
await client.initialize()

# The LLM decides when to call MCP tools, no manual orchestration
response = await client.ask_question(
    "Get Tesla's latest earnings and calculate key financial ratios"
)
# 1. LLM calls `search` to find the right dataset
# 2. LLM calls `fetch` to retrieve earnings rows
# 3. LLM analyzes the data and computes ratios
# 4. Returns the synthesized answer

The agent only sees datasets your software statement allows. Same dataset-permission model as the MCP service, the SDK is a thin client over it.

Method Reference

All clients implement the same interface regardless of provider. Persistent clients add session lifecycle methods on top.

Method Use case
initialize() Set up MCP connection. Required before any query.
ask_single_question(q) One-shot query, no history. Quick lookups.
ask_question(q, ...) Flexible query with history / memory toggles. Most common.
process_query(q) Streaming output with maintained history. Real-time UIs.
cleanup() Tear down connections. Required at shutdown.
establish_persistent_connection() Persistent client, open long-running MCP session.
ask_with_persistent_session(q, ...) Persistent client, query within the open session.
close_persistent_connection() Persistent client, close the session cleanly.

What You Can Build

The SDK is general-purpose. Three concrete patterns, each plugs into the same MCP server, and the permission layer limits access to what its software statement allows.

01

News agent

A focused news brain.

Software statement scoped to MT Newswires, CityFalcon, or both, nothing else. Drop-in for apps that need a single-purpose news layer.

02

Fundamentals agent

Reported financials only.

Knows reported financials, normalized statements, EPS forecasts, nothing about news or pricing. The narrowest possible scope, full depth.

03

Custom Financial Chat Agent

Your own Financial Chat Agent.

Same kind of full-coverage agent we productize as Financial Chat Agent, on your own infra, your own LLM, your own memory layer, your own UI. The SDK gives you the pieces; you assemble.

Next Steps

The SDK code is free and MIT-licensed. To reach data you need a viaNexus account, software statements are issued from your account, and the MCP server only serves agents whose statements it can validate.

GitHub repo

Dataset Catalog

Dataset
Catalog.

The catalog shows what an agent can actually access: NexusCore datasets are included with every plan, while NexusEdge partner datasets can be added one subscription at a time. Your software statement and token permissions enforce that access across MCP, Financial Chat Agent, and the SDK.

NexusCore

14

bundled datasets

NexusEdge

16+

premium add-ons

Partners

7+

data providers

Bundled with every plan, available to every subscriber by default.

For Data Providers

Your dataset joins the catalog alongside NexusCore + NexusEdge, reachable through MCP, Financial Chat Agent, and SDK without you rebuilding licensing or auth.

Become a data partner

If you publish financial data, vAST is a distribution channel into AI agents. You bring data; viaNexus handles the MCP, OAuth, dataset permissions, and billing.

What viaNexus handles

Normalization

Schema mapping into the viaNexus standard.

Concordance

Entity resolution across providers and identifiers.

Access control

OAuth, software statements, dataset-permission patterns, commercial vs. personal, geo, rate limits.

Monetization

Subscriptions, billing, and usage metering. Transparent revenue share.

Resources

Demos,
Articles,
Skill Packs.

Demos, articles, and skill packs. Install one in Claude, pair with the viaNexus MCP, run on real dataset permissions.

Selected viaNexus articles for agent builders, data engineers, and MCP users.

View all on blog →
Blog May 2026

MCP Gave Agents the Door. It Didn't Give Them a Key.

viaNexus extends MCP with scoped, signed credentials for financial data. Works with Claude, Cursor, and any MCP client.

Blog Jan 2026

When AI Sounds Confident but Doesn’t Know Better

Whether you’re vibe-coding an app at home — or building a professional GPT to support finance professionals — you need reliable, verified, authoritative data delivered in a form your project can effortlessly consume. That's where viaNexus Agentic Services Technology (vAST) comes in.

Blog Jan 2026

2025 - what a year!

From a bold idea and a bare-bones plan to a live, high-performance marketplace, 2025 was the year viaNexus proved a new model for market data and agentic workflows isn’t just possible—it’s necessary. We’re heading into 2026 ready to scale!

Blog Oct 2025

Defeating Hallucination in Financial AI: From Determinism to Data Integrity

LLMs can’t be trusted with math—or data scraped from the web. viaNexus and vAST eliminate hallucination from the ground up with licensed, structured, and precalculated data. Deterministic, auditable, and built for finance—where “close enough” isn’t good enough.

Blog Sep 2025

Understanding a Financial AI Agent and Avoiding AI Agent Washing

AI agents are poised to revolutionize industries, but the true potential of these autonomous entities is often obscured by "AI Agent Washing"—a deceptive practice that misrepresents a system's capabilities.

Blog Sep 2025

Financial Agents….The Dawn of New Era

This article details viaNexus' Agentic Workflow service, extending OAuth 2.0/2.1 to enable scalable, autonomous agents in finance. It overcomes traditional OAuth's limits with pre-authorized scopes, and securing agent authentication and authorization.

Blog Jul 2025

Agentic Workflows: Overcoming Current Limitations

Agentic workflows, designed to automate complex tasks, hold immense promise for boosting productivity and efficiency. However, current implementations face several significant shortcomings that hinder their full potential. This blog post will explore these challenges, particularly foc...

Pre-built skills for Claude live in GitHub. Clone into ~/.claude/skills/, or open Raw on each skill and paste the SKILL.md into Claude with "Please save this as a skill.", then pair with the viaNexus MCP connector for live data.

All skills on GitHub →

Financial Research

Earnings, fundamentals, peer comparison.

News & Sentiment Analyst

Real-time news, sentiment, alerts.

Transcript Analysis

Earnings calls, key quotes, Q&A.

Portfolio Monitor

Holdings, price alerts, daily briefs.

Start building.

14-day free trial. No credit card. Connect to 30+ financial datasets through your AI in under two minutes.

Or jump to the MCP quickstart if you already have an account.