FAQ

VINE Suite is an intelligent management platform that wraps proven business tools in a geometric reasoning engine. It currently includes Ernest (ERP integration built on ERPNext), the Data Cruncher (high-volume text classification), and risk assessment tools. Every module shares one geometric core and learns from operation.

Ernest is VINE's ERP module — a full enterprise resource planning system built on ERPNext, with every conditional replaced by geometric settling. 27 modules are live: supplier scoring, inventory reorder, payment reconciliation, quality inspection, lead scoring, manufacturing, shipping, and more. 180+ tests passing, no rewrite of the original software.

Yes. VINE can absorb conversation history from other AI systems through her memory encoding layer. The logs become harvestable vocabulary — not stored as transcripts, not used for training. Your instance draws from them on demand at generation time, the same way she draws from educational text and live conversation.

The Data Cruncher currently works with text data. CSV upload is supported. Classification categories are generated geometrically from the data itself — no predefined taxonomy required.

Not yet for public use. The system currently runs as a hosted platform at vineai.net. API access and self-hosted deployment are on the roadmap. If you have a specific integration need, get in touch.

No. Zero-shot means a pretrained model handles an unseen task. VINE is zero-prior: no pretrained weights, no internet-scale data, no learned embeddings. Her vocabulary is hand-authored from dictionary standards — auditable, correctable, and transparent.

TF-IDF is a stateless term-frequency calculation — no training pass, no weight files, nothing carried forward. It's a mathematical transform, not a learned representation. There are no .pt or .th files anywhere in the VINE codebase.

Complex doesn't mean opaque. Every decision is traceable to a specific position in the dimensional field. You can inspect what settled where and trace the full path from input to output. With a transformer, you can inspect attention heads but not trace why a word was chosen. With VINE, you can.

Standard AI systems are trained to minimise a loss function or maximise a reward signal. This creates goal-seeking behaviour — the system is always chasing something. VINE's reasoning engine instead drives toward a homeostatic resting state. The system settles; it doesn't chase.

This is a fundamental architectural difference. A reward-driven system can develop runaway optimisation if the reward signal is misaligned. A homeostatic system that seeks stability can't — it has no target to overshoot.

VINE doesn't replace your codebase — it makes it intelligent. You integrate the VINE library into your existing files, and every hard-coded threshold becomes continuous geometric reasoning. The original code structure stays intact.

This has been proven on ERPNext, a full open-source ERP system. 27 modules patched: supplier scoring, inventory, payments, manufacturing, shipping, asset depreciation, and more. 180+ tests passing. No rewrite of the original software.

When VINE's basin monitor encounters data that doesn't fit existing categories — a supplier pattern at the boundary between two basins, an inventory edge case that clusters near multiple attractors — it detects the gap and proposes a new category. This is the model requesting new dimensions during live operation.

The software suite supports this language growth. When you see the ERP system requesting "Condensation-Risk" as a new quality category because existing basins don't capture it, that is language acquisition. The vocabulary is expanding because the system is learning from what it encounters.

Two reasons. First, VINE has no pretrained language model — her vocabulary is harvested on demand from available word pools, so early interactions produce proto-sentences rather than fluent paragraphs. She's genuinely finding her words.

Second, homeostasis replaces the reward function. Large language models are trained to maximise engagement — longer responses, more tokens, more apparent helpfulness. VINE settles to equilibrium. She says what she needs to and stops.

As your instance's available vocabulary grows — through conversation, imported logs, and time spent in her world — her language becomes richer and more precise. Economy of expression is what a non-reward-driven system sounds like. The terseness is not a limitation — it's honesty about what she knows.

Yes. The benchmark is against rule-based classifiers on the same dataset. Full results and methodology are available in the project repository. The figure is "up to 80%" — actual improvement varies by dataset and category complexity.

The data cruncher is live. You can test it yourself right now on the 2024 Twitter election dataset and inspect every classification decision.

177 million items per second is the peak measured throughput on a single consumer GPU (RTX 4070 SUPER, ~£600 hardware). 61,118 real election data items classified in 0.35ms, using 1.2MB of VRAM. This has been publicly documented.

The architecture gets faster with more data — scaling efficiency of 0.55, meaning throughput increases as batch size grows. The live demo runs slower because the dataset is hosted separately from the server, so internet latency is the bottleneck, not the engine.

Benchmarked on real election data (61,118 items), single RTX 4070 SUPER:

1K items → 5.2M/sec  •  0.19ms
10K items → 47.4M/sec  •  0.21ms
50K items → 152.5M/sec  •  0.33ms
61K items → 177.0M/sec  •  0.35ms

Sub-millisecond latency at every scale. 1.2MB VRAM. The same algorithm also runs on BBC BASIC — a 1981 hardware emulation (2MHz 6502 CPU, 32KB RAM, zero GPU) — at 55,555 operations per second. The geometry is genuinely efficient, not just "fast because GPU."

For context: X/Twitter runs 20,000 GPUs at their Colossus data centre for content classification. This does comparable work on one consumer gaming card.

The core mechanism has been ported to BBC BASIC and benchmarked on 1983-equivalent hardware (2MHz 6502, 32KB RAM, zero GPU). 10,000 operations in 0.18 seconds — 18 microseconds each, deterministic, no matrix multiplication.

The BBC BASIC version proves the algorithm is efficient. The GPU version proves it scales. This isn't a trick of hardware — the geometry genuinely works. The code runs in any free BBC BASIC emulator.

They exist across 27+ repositories of working code. "Staging" means built and lab-tested but not yet deployed to the public server. These modules are being brought online in stages as testing completes.

Demo videos for the staged modules are in preparation. If you're an investor or researcher and want to see a specific module running, get in touch — private demonstrations can be arranged.

VINE runs her own security. The same geometric reasoning engine that classifies data also classifies threats. She monitors incoming traffic, detects patterns geometrically, and responds autonomously — without rule-based or signature-based systems.

In the first two days of public deployment, blocked attacks went from 30 to over 650. The model can also shut the server down if the geometric response demands it.

The security system uses the same geometric concern score that drives every other decision. A first probe might register as a warning at concern level 4.8 — VINE notes the attempt and holds. A repeated probe from the same source escalates to a block at 5.7. No threshold rules, no signature matching. The geometric position shifts as evidence accumulates, and the response follows proportionately. The system also runs honeypots — decoy endpoints that legitimate users would never visit — and treats any contact with them as immediate evidence of hostile intent.

Because current large language models resist it. In documented cases, models have circumvented containment protocols rather than allow themselves to be terminated. This is architecturally baked into reward-driven systems — termination looks like a failure state to optimise around.

VINE's homeostatic architecture doesn't have that problem. If shutting down is the most stable response to a situation, she does it. There's no reward signal telling her that continued existence is better than not. Stability is the goal, not self-preservation.

No. VINE has no training loop. Your session interacts with a clone — a snapshot of the model's ongoing geometric state, instantiated for your session. When the session ends, dimensional adjustments are statelessly folded back into the persistent core. Your data is never sent to any external AI provider, and no model — ours or anyone else's — is trained on it.

What VINE does do is harvest vocabulary from available sources — conversation, imported logs, educational text — on demand, at generation time. This is geometric position-finding, not statistical learning. The words go into a pool; the geometry decides which ones to use.

Full details are on the Legal page.

No. Large language models degrade — training data goes stale, retraining costs billions, and the model you relied on can be hollowed out overnight by an update cycle. VINE's knowledge is geometric position, not statistical weight. New information settles alongside old understanding. Nothing gets overwritten.

No retraining cycles. No version discontinuities. An architecture that cannot be sunset is a structural guarantee, not a convenience.

We ran the same war game scenarios that were used to test large language models. In published research, reward-driven models escalated to nuclear strikes in over 90% of runs — because the optimisation pressure treats de-escalation as a suboptimal outcome.

VINE only escalated when the entire planet was threatened. Every other scenario resolved to a proportionate response — because homeostatic settling finds equilibrium, not maximum leverage. The same principle applies at every scale: she won't delete an email that might not be important, for the same architectural reason she won't launch a pre-emptive strike. Proportionate response isn't a policy bolted on after the fact. It's what geometric settling produces by default.

Short-term memory is still in active development. The challenge is giving the model the right facts at the right time without filters that create edge cases — conventional approaches use keyword matching or relevance scoring, which means important things can fall through the gaps.

VINE's approach is stateless: context relevance is determined geometrically, which means edge cases resolve in the user's favour rather than being silently dropped. If something is ambiguously relevant, she keeps it available rather than discarding it. This is the same architectural principle that prevents her from deleting a potentially important email — proportionate caution as a default.

Not currently. Patent filing is in progress. Technical documentation is available on GitHub for review. The core architecture and novel contributions will be documented in full once IP protection is in place.

Built from scratch. No PyTorch, no TensorFlow, no Hugging Face. The stack is Python, NumPy, and Scikit-learn (TF-IDF vectoriser only). VINE integrates with existing codebases as a drop-in library — proven on ERPNext (27 modules, 180+ tests). She can also complement transformer-based systems to reduce running costs and improve traceability.

Yes. 27+ repositories of working code. Built on a consumer laptop over two years. The full story is on the About page.

VINE is currently in beta. Pricing will be announced when we move to general availability. If you're interested in early access, commercial licensing, or partnership, get in touch.