AetherGrid Sentinel is an opinionated, event-driven trading mesh built for people who want to orchestrate systematic accumulation and distribution strategies across volatile digital asset markets — without needing to babysit a terminal every waking hour. It is the spiritual successor to the original MFDLABS Grid Bot lineage, but reimagined from the ground up as a modular, observable, and horizontally scalable framework.
Where the ancestral grid bot was a single-purpose workhorse, AetherGrid Sentinel is a small constellation of cooperating services: a strategy planner, a risk arbiter, a market data relay, an execution orchestrator, and a telemetry spine. Each service speaks a narrow protocol, and together they form a resilient lattice that keeps working even when a single node stumbles.
This repository is the canonical home of the Sentinel codebase. If you arrived here through a support URL, please head to the Issues tab and open a ticket — that is the fastest route to a human response from the maintainers.
Philosophy in one line: Markets are weather, not warfare. Build shelters, not swords.
- What Makes Sentinel Different
- Feature Highlights
- Architecture at a Glance
- Strategy Engine Deep Dive
- Responsive Interface Layer
- Multilingual and Locale-Aware Design
- Always-On Support Model
- Configuration Surface
- Observability and Telemetry
- Security Posture
- Roadmap for 2026
- SEO and Discoverability Notes
- Frequently Asked Questions
- Disclaimer
- License
Most grid systems are a single binary with a config file. They work beautifully in demos and fall apart the moment the network hiccups or the exchange throttles a request. Sentinel takes the opposite stance: assume failure, embrace latency, and design for graceful degradation.
The result is a system where:
- Every component is replaceable. The planner does not care which exchange adapter is plugged in, as long as the adapter honors the contract.
- Every decision is auditable. Each grid realignment is written to an append-only journal with a reason code.
- Every metric is exposable. The telemetry spine emits structured events that any downstream collector can ingest.
- Every operator is respected. The dashboard remembers your last view, your color theme, and your preferred decimal precision.
This is not a toy. It is a workshop.
A curated tour of what ships in the current trunk:
- ⚙️ Adaptive grid spacing — spacing recalculates based on realized volatility windows, not static percentages.
- 🧠 Pluggable strategy modules — drop in a new allocator without touching the executor.
- 🌐 Multilingual support — human-facing strings are externalized; ship a new locale as a single file.
- 📱 Responsive UI — the control surface reshapes itself for tablets, phones, and ultrawide battlestations alike.
- 🛰️ 24/7 customer support posture — rotating maintainer coverage and a triage bot that pre-labels incoming reports.
- 🔐 Least-privilege execution — adapters request only the scopes they actually use.
- 📊 Rich telemetry — Prometheus-style counters, structured JSON logs, and a live event bus.
- 🧪 Deterministic backtesting — replay historical tapes through the same code path as live execution.
- 🗺️ Multi-venue routing — spread exposure across compatible venues with a single strategy definition.
- 🧩 First-class theming — every surface is themeable without a rebuild.
- 📦 Portable profiles — export and import strategy bundles as plain text artifacts.
- 🕰️ Time-travel replay — rewind the dashboard to any past window and inspect decisions frame by frame.
Sentinel is arranged as five cooperating planes:
1. The Planning Plane — a long-running service that watches market streams and decides when a grid should be born, retired, or rebalanced.
2. The Execution Plane — a short-lived, horizontally scalable pool of workers that translate planner intents into venue-specific actions.
3. The Market Data Plane — a multiplexed relay that normalizes feeds from multiple venues into a single internal tick format.
4. The Telemetry Plane — a bus that carries metrics, traces, and audit events to whatever sinks you configure.
5. The Experience Plane — the responsive dashboard, the CLI companion, and the notification gateway.
These planes communicate over a lightweight internal protocol. You can run all five on a single laptop for development, or spread them across a small fleet for production.
The strategy engine is the heart of Sentinel, and it is deliberately boring. Boring is a compliment here — boring means predictable, and predictable means sleep.
A strategy definition contains:
- Grid geometry — how many rungs, how wide, and how the spacing interpolates.
- Capital envelopes — the maximum exposure per rung and per strategy.
- Trigger predicates — the conditions under which a rung becomes active.
- Decay rules — how old rungs are pruned when the market regimes shift.
- Exit policies — what happens when a rung fills, partially fills, or times out.
Each of these is expressed in a small declarative dialect. You can hand-write a strategy, or generate one from the interactive planner.
Every planner decision carries a reason code. A short catalog:
GRID_INIT— a fresh grid was instantiated.RUNG_FILL— a rung crossed its price and executed.VOL_SHIFT— volatility window forced a respacing.RISK_HALT— the risk arbiter paused new opens.DECAY_PRUNE— a stale rung was removed.
These codes appear in the audit journal and in the dashboard timeline, so you can always answer the question: why did it do that?
The dashboard is built to be legible on whatever glass you happen to be holding. It leans on a fluid grid, container queries, and a small set of hand-tuned breakpoints.
Design goals:
- No horizontal scrolling on devices as narrow as 320 logical pixels.
- Thumb-reachable controls for the actions you take most often.
- Reduced-motion mode that respects the operating system setting.
- High-contrast palette toggle for daylight readability.
- Persistent layout memory so your workspace looks the same when you return.
The experience extends to a companion CLI for operators who prefer keystrokes to clicks. The CLI and the dashboard talk to the same API, so there is no feature drift between them.
Sentinel treats language as a first-class concern, not an afterthought layered on at the end.
- All user-visible strings live in translation catalogs keyed by semantic identifiers.
- Number formatting, currency symbols, and date rendering defer to the active locale.
- Right-to-left layouts are supported without a separate code path.
- Pluralization follows the CLDR rules for each language family.
- A translation linting step runs in continuous integration to catch missing keys before merge.
Community translations are welcomed through the standard contribution flow. If your language is missing, the catalog skeleton is already scaffolded — you only need to fill in the values.
Support is not a ticket queue that sleeps. Sentinel maintains a rotation of maintainers across time zones, backed by a triage bot that:
- Auto-labels incoming reports by area (planner, executor, data, UI).
- Requests a minimal reproduction bundle when a report lacks one.
- Pings the on-call maintainer when severity thresholds are crossed.
- Posts a weekly digest of open items to the community board.
If you arrived here via a support URL, the Issues tab is the correct destination. Please include your version string, the reason code you observed, and a redacted slice of the journal if the problem involves a specific decision.
Configuration is layered, with later layers overriding earlier ones:
- Compiled defaults — sane values that let a fresh checkout run immediately.
- Environment overrides — useful for containerized deployments.
- Profile documents — the portable strategy bundles you export from the planner.
- Runtime adjustments — temporary tweaks made through the dashboard that expire on restart.
Every configuration key is documented in the schema file at the repository root. The schema doubles as the validator, so a malformed profile is rejected before it can do harm.
You cannot improve what you cannot see. Sentinel emits three classes of signals:
- Metrics — counters, gauges, and histograms for rung fills, planner decisions, and queue depths.
- Traces — a lightweight span tree for each execution path, so slow steps are obvious.
- Audit events — the human-readable journal that explains why something happened.
These signals flow to the telemetry plane, which can forward them to your preferred collector. Nothing is mandatory — you can run with telemetry fully disabled and lose nothing but visibility.
Security in Sentinel is a stance, not a feature checkbox.
- Adapters declare the minimum scopes they require, and the runner refuses to elevate them.
- Secrets are never written to the journal; the journal redaction pass strips anything that looks like a credential.
- Web surface ships with a strict content security policy by default.
- Dependency updates run on a scheduled cadence, and a lockfile diff is generated for every bump.
- The threat model document lives alongside the code and is updated with each meaningful change.
If you believe you have found a vulnerability, please follow the coordinated disclosure process outlined in the repository's security policy rather than filing a public issue.
A non-exhaustive sketch of where things are heading:
- Q1 2026 — Multi-account isolation and per-account risk envelopes.
- Q2 2026 — A visual strategy composer with drag-to-arrange rungs.
- Q3 2026 — Community strategy registry with signed bundles.
- Q4 2026 — Cross-venue hedging primitives and a simulation mode that shares the live code path.
Roadmap items are aspirational. Priorities shift with community feedback and maintainer capacity.
This section exists for the humans who curate and the crawlers that index. Sentinel is described across this document using natural phrasing around recurring themes: adaptive grid trading framework, event-driven execution mesh, multilingual trading dashboard, responsive operator interface, always-on support posture, auditable strategy journal, and multi-venue routing engine.
These phrases appear where they belong in the prose. They are not stuffed into a hidden footer or a keyword graveyard. The goal is clarity for readers, and discoverability is a happy side effect.
Is Sentinel a drop-in replacement for the original grid-bot? It shares the spirit and the terminology, but the internals are a ground-up redesign. A migration note in the docs folder walks through the mapping from legacy configuration keys to Sentinel profiles.
Do I need to run all five planes? No. A single-process mode bundles them together for evaluation and small deployments.
Can I bring my own exchange adapter? Yes. The adapter contract is small and documented, and a reference adapter ships in the tree.
How do I contribute a translation? Fork, fill in the catalog skeleton for your language, and open a pull request. The linting step will tell you if anything is missing.
Where do I report a bug? The Issues tab. Include your version string and a reproduction bundle.
Is there a community chat? The maintainers publish a link in the repository's discussion board. It is listed there so it can be rotated without editing this file.
AetherGrid Sentinel is provided as a software toolkit for research, education, and personal automation. It is not financial advice. It is not a promise of profit. It is not a substitute for your own judgment.
Markets can move against you faster than any grid can rebalance. Digital assets can lose value permanently. You are responsible for every action your instance takes, for every credential you configure, and for every jurisdiction-specific rule that applies to you.
The maintainers provide this software on an as-is basis under the MIT license. They do not manage your capital, they do not custody your assets, and they cannot recover funds that were lost through misconfiguration or market movement.
Before you point Sentinel at anything you care about, run it against a replay tape first. Then run it against a small envelope. Then, if you are still comfortable, scale up slowly. Patience is a feature.
This project is distributed under the MIT License.
You can read the full text of the license here: MIT License
Copyright (c) 2026 AetherGrid Sentinel contributors.
Permission is granted, without charge, to any person obtaining a copy of this software and associated documentation files, to deal in the software without restriction, including the rights to use, copy, modify, merge, publish, distribute, sublicense, and to permit persons to whom the software is furnished to do so, subject to the conditions set forth in the MIT License.
The software is provided without warranty of any kind, express or implied.