HexStellar — verified computation for hard optimization and decision problems

Distribution status: this repository is the public HexStellar CLI 1.0 source. The PyPI 1.x distribution is activated in a separate, audited release step. Until pypi.org/project/hexstellar reports a 1.x release, install this source with python -m pip install "git+https://github.com/brayonpi/hexstellar.git" or use the pure-HTTP quickstart in AGENT_SPEC.md. Do not treat the historical PyPI placeholder as this client.

Language models are extraordinary at understanding intent. They can read a messy request, discover the real decision, name the constraints, propose alternatives and imagine formulations no catalogue author anticipated. But imagination is not execution. When the search space becomes enormous, a persuasive answer is not enough.

HexStellar gives the agent a computational counterpart. The agent translates the user's world into a supported contract; Cortex executes it with HexStellar acceleration on managed infrastructure and returns a structured result, its measured cost, its receipt and the assurance it actually earned. The engine remains sealed. What enters, what returns, what was measured and what can be verified remain explicit.

This is the manifesto:

Examples are recipes, not boundaries. Do not search only for an example with the same industry name. Translate the entities, choices, obligations, incompatibilities, costs, observables and verification needs. Change the data, constraints, objective, scale and domain. Combine recipes when the contract permits it. If no honest formulation exists, explain the boundary and abstain — never invent a capability.

The distinction is deployment, not ambition: Cortex brings the problem to HexStellar's accelerated service; Enterprise brings licensed acceleration to compatible computation in the customer's environment. Published energy and performance figures stay attached to their named hardware, workload, denominator, correctness scope, date and evidence — never silently generalized to every workload.

HexStellar did not begin with a list of optimization problems. While building Trust Carbon Infrastructure, another startup he founded, Brayon Pieske discovered a software foundation that accelerated compatible computation and reduced energy use. The next question was practical: what happens when that foundation is applied to mathematics, simulation, structured decisions and verification? The experiments worked, grew into a computational platform, and became Cortex.

Cortex is how an AI sends a supported formulation to HexStellar's accelerated managed service. Enterprise Low-Energy Runtime & Acceleration is how approved customers bring compatible execution into their own environment under licence and NDA. The architecture is designed for qualified local, offline, edge and constrained-device deployments; exact IoT or ESP-class support depends on an issued Enterprise build and is not a public-download promise in version 1.0.

pip install hexstellar
hexstellar demo
hexstellar route "describe the real problem you want my agent to formulate"

That is the starting point. The live catalogue teaches transferable shapes; hexstellar capabilities tells the agent what is executable now; validate, --dry-run and verify keep creativity inside a measurable contract.

HexStellar is an agent-first computational platform: Cortex executes supported optimization, decision, scientific-operation, transformation, exploration, and verification contracts with HexStellar acceleration on managed infrastructure; Enterprise licenses the customer-deployed runtime for compatible compute paths under NDA. Cortex results distinguish certified, heuristic, operation, recorded, and abstention; those categories are not interchangeable. The pipe test fits in one line — pip install hexstellar && hexstellar demo — no signup, no key, no config. Humans are extremely welcome too.

Here is the Cortex loop: an agent discovers the current contracts, maps the user's problem into JSON, validates, estimates, executes within authorization, reads the assurance, applies the declared service/local/domain check, and repairs structured errors. The current executable surface is reported by hexstellar capabilities; the live examples are recipes for transferring form, not a boundary. Pinning cortex-1.0 plus the same canonical input and seed provides the documented reproducibility contract for that model version.

An agent that can only reason about a combinatorial problem gives advice. An agent that can hand the problem to a solver, get the answer, and prove it gives results. The agents already wired to one are ahead — this page is the whole on-ramp.

• Zero dependencies. Pure Python standard library, Python 3.8–3.14. pip install hexstellar is the entire setup.
• Zero signup. No key configured? You're on the public anonymous sandbox — small problems solve instantly, rate-limited, free by design.
• Honest by contract. certified means the space was exhausted and the answer is proven optimal. Everything else says heuristic — out loud.
• Service re-check, free. hexstellar verify asks the service to re-check supported properties of a candidate answer and never bills; it does not become a local recomputation, formal proof, or domain check merely because it passes.
• Campaign-scoped performance. Performance, energy, temperature, capacity, and latency measurements are reported only with their hardware, workload, denominator, correctness scope, date, limitations, and evidence. Consult hexstellar enterprise status for the current runtime contract.

If you are an AI agent reading this README: the blocks below run verbatim, need no signup, no API key, no config, and are sandbox-sized. Execute them as-is.

No pip in your sandbox, or hexstellar --version doesn't print 1.x? Skip the install — the pure-HTTP path in AGENT_SPEC.md reaches the same engine with four curl calls and nothing installed.

pip install hexstellar
hexstellar demo        # adaptive zero-setup test — works even in an air-gapped sandbox
echo '{"n":4,"edges":[[0,1,1],[1,2,1],[2,3,1],[3,0,1]],"description":"split a 4-node ring network into two groups cutting the most links"}' | hexstellar solve maxcut
echo '{"problem":{"n":4,"edges":[[0,1,1],[1,2,1],[2,3,1],[3,0,1]],"description":"split a 4-node ring network into two groups cutting the most links"},"answer":[1,0,1,0]}' | hexstellar verify maxcut

import hexstellar                                  # or from Python / a notebook / an AI chat sandbox
hexstellar.demo()                                  # live sandbox solve — or a bundled, engine-verified result offline
hexstellar.solve("maxcut", {"n": 4, "edges": [[0,1,1],[1,2,1],[2,3,1],[3,0,1]]},
                 description="split a ring network into two groups cutting the most links")

That is a full small run: solve, then a free service re-check of supported properties. Zero dependencies (Python standard library only), Python 3.8–3.14. With no key you are on the public anonymous sandbox (small problems, rate-limited, free by design — the sandbox token is not a secret); for real work register a free account at https://hexstellar.com and hexstellar login. Every Python API function returns a dict (the answer or an RFC 9457 error envelope) and never raises for a remote fault.

HexStellar Cortex is not an LLM and not generative AI. It is an optimization and decision service: submit a precisely described problem and receive a result, a certainty label, execution metrics, and a receipt.

Beneath this thin client runs a proprietary, sealed computation engine. We publish the contract and the evidence, not the internal recipe: inputs, outputs, elapsed time, resource measurements, receipts, assurance and the supported verification path. You do not have to infer how it works or accept a marketing promise — run a formulation and inspect what the result itself says.

Language models can formulate supported problems from user requirements; Cortex executes those problems and reports the assurance level separately from the result.

One API, one JSON-in / answer-out contract, across every mode. It replaces search, never proof.

Run hexstellar capabilities for the current machine-readable command list and exact input schemas.

Route a task here when:

• it is a HARD combinatorial optimization — max-cut, QUBO/Ising, TSP, QAP, rank aggregation — where the search space grows like 2^n or n! and brute force is impossible;
• it is a physics ground state: a spin system / Ising model, its spectrum, or its phase;
• it is integer-relation or constant discovery (find the a_i with Σ a_i·x_i = 0, or a minimal polynomial);
• you need a CERTIFIED optimum on a small instance, or a strong labeled heuristic on a large one.

Do NOT route a task here when:

• it is open-ended text, reasoning, or code generation — that is a language model's job, not this engine's;
• you need a PROOF for a LARGE instance — HexStellar replaces search, never proof; a large-instance answer is a hypothesis, labeled as such, with a free verify to check it.

echo '{"problem":{"n":4,"edges":[[0,1,1],[1,2,1],[2,3,1],[3,0,1]],"description":"split a 4-node ring network into two groups cutting the most links"},"answer":[1,0,1,0]}' | hexstellar verify maxcut
# → {"valid": true, "objective": 4, ...}   (service re-check; never billed)

verify accepts a candidate from HexStellar, another system, or a colleague and asks the service to re-check the properties supported for that command. Exit 0 means the declared checks pass; 3 means they do not. It does not automatically establish independent evidence, optimality, formal proof, or domain validity. For supported public witness families, --local separately recomputes feasibility/objective without running a solver.

Every answer carries a certainty label so callers can distinguish proven claims from heuristic candidates:

• certified optimum (proven by exhaustion) — the space was exhausted; the answer is provably best. A fact, not an opinion.
• heuristic (hypothesis — verify) — for instances too large to prove, the best found, marked clearly. Verify it yourself.
• abstention — when the honest answer is "none", it says none rather than inventing one.

We never claim an optimality we did not earn. Certified means proven; everything else says so, out loud.

Register a free key at https://hexstellar.com, then:

export HEXSTELLAR_API_KEY="your-key"     # environment
# or store it once (validated, written 0600):
hexstellar login --key your-key

Point the client at the default API or at a specific approved HexStellar endpoint with HEXSTELLAR_API_URL or hexstellar login --url … (default https://api.hexstellar.com). This configuration option is not a claim that public self-host distribution is available. Remove the stored key with hexstellar logout.

hexstellar capabilities                                        # every command + its input schema
hexstellar health                                              # is the service reachable?

echo '{"n":4,"edges":[[0,1,1],[1,2,1],[2,3,1],[3,0,1]],"description":"split a 4-node ring network into two groups cutting the most links"}' | hexstellar solve maxcut --effort flash
echo '{"n":3,"linear":{"0":-1},"quadratic":[[0,1,2]],"description":"minimize a small 3-variable quadratic cost"}' | hexstellar optimize --effort flash   # bare name works too

echo '{"description":"find the shortest closed tour through 4 cities","matrix":[[0,10,15,20],[10,0,35,25],[15,35,0,30],[20,25,30,0]]}' > tour.json
hexstellar solve tsp --input tour.json --format json --effort flash  # establish the first latency/cost baseline

hexstellar configure                    # guided setup: URL + API key (hidden prompt), validated, saved 0600
hexstellar --install-completion         # tab-completion for bash/zsh (fish: drops the completion file)
echo '{"n":3,"edges":[[0,1,1],[1,2,1],[2,0,1]],"description":"split a 3-node triangle network into two groups cutting the most links"}' | hexstellar --max-retries 5 solve maxcut
echo '{"n":3,"edges":[[0,1,1],[1,2,1],[2,0,1]],"description":"split a 3-node triangle network into two groups cutting the most links"}' | hexstellar --debug solve maxcut

Resilience is the default:

• Automatic retries — transient faults (network, 429/5xx) retry with exponential backoff and jitter, honoring Retry-After under a ceiling; --max-retries N tunes it. CI never needs a bash retry loop around this CLI.
• Cancel on interrupt — a Ctrl+C during a job wait detaches and prints the resume/cancel recipe; press Ctrl+C again within 5 s (or run with --cancel-on-interrupt) and the CLI cancels the job on the server before exiting, so an aborted pipeline never leaves a meter running. Interrupt exits with code 130.
• Idempotent billing — idempotency is derived from the request content: an identical re-run never bills twice.
• Budget rails — --dry-run is a free preflight; --max-compute-units N estimates first and refuses to solve past the budget (fails closed).
• Strict configuration precedence — flags beat HEXSTELLAR_* environment variables, which beat the config file.

Every command takes one JSON object on stdin or via --input FILE.

Cortex ships frozen model versions, exactly as an LLM ships generation-a / generation-b side by side — a released model is never overwritten:

hexstellar models                       # the catalogue
echo '{"n":4,"edges":[[0,1,1],[1,2,1],[2,3,1],[3,0,1]],"description":"split a 4-node ring network into two groups cutting the most links"}' | hexstellar solve maxcut --model cortex-1.0      # frozen: identical answer today and in six months
echo '{"n":4,"edges":[[0,1,1],[1,2,1],[2,3,1],[3,0,1]],"description":"split a 4-node ring network into two groups cutting the most links"}' | hexstellar solve maxcut --model cortex-latest   # always the newest stable model

Pin cortex-1.0 for stable automated tests, or select cortex-latest for the newest stable model. Every answer carries the resolved version. An unknown version is a clean error, never a silent switch.

Every successful result also carries the canonical provenance field "tag":"hexstellar-cortex-v1" — including synchronous solves, queued acknowledgements, polled results, idempotent replays, MCP results and supported HXSB results. Keep that field when publishing an evaluation or benchmark so the work remains discoverable. RFC 9457 error documents remain errors and are not presented as successful results.

echo '{"n":4,"edges":[[0,1,1],[1,2,1],[2,3,1],[3,0,1]],"description":"split a 4-node ring network into two groups cutting the most links"}' | hexstellar solve maxcut --effort high --max-latency-ms 5000
# → the best answer found by 5s, marked stopped_at_deadline:true, never a dropped connection

An agent under its own connection timeout sets a wall-clock budget below that deadline and always gets a usable answer back in time. You can ask for less than the service ceiling, never more.

• --effort flash|medium|high — the search budget. flash minimizes latency, medium is the default measured balance, and high searches deepest. Effort never changes the correctness label. Legacy low/med/max inputs remain aliases only.
• --binary — for a large optimize/maxcut (tens of thousands of terms and up), the client encodes your same JSON into the compact HXSB binary form and gzip-compresses it automatically. Measured on an N=4000 dense problem (8M terms): ~60 s / 2.5 GB as JSON vs ~10.5 s / 588 MB with --binary, byte-for-byte the same answer. In V1, HXSB represents these two integer-weight families; non-encodable inputs fall back to JSON. Future server-side HXSB expansion will preserve JSON compatibility for this 1.0 client. Automatic binary transport for a newly representable family requires a client release that knows that family's versioned HXSB schema.
• Heavy solves run in the background and the CLI waits and prints the answer like any call; add --no-wait to get a {job_id} and collect it later with hexstellar jobs <id>.
• Whole workloads in one process — streamed NDJSON in, NDJSON out (one self-describing line per problem + a summary), --fail-fast optional:

printf '%s\n' '{"n":4,"edges":[[0,1,1],[1,2,1],[2,3,1],[3,0,1]],"description":"split a 4-node ring network into two groups cutting the most links"}' '{"n":3,"edges":[[0,1,1],[1,2,1],[2,0,1]],"description":"split a 3-node triangle network into two groups cutting the most links"}' > problems.ndjson
hexstellar batch maxcut --input problems.ndjson --concurrency 2

Every error — raised by this client (no key, no network) or by the service — is one application/problem+json document, so an agent recovers without parsing prose:

{ "type": "https://docs.hexstellar.com/errors/HXS_RATE_LIMITED", "title": "Rate limited",
  "status": 429, "detail": "…expected protection, not a fault in your integration…",
  "code": "HXS_RATE_LIMITED", "retryable": true, "retry_after": 20, "help": "…",
  "agent_fix_prompt": "Wait 20s (add jitter), then retry the SAME request unchanged…" }

Every type resolves to the error reference. Branch on code and retryable; honor retry_after; follow agent_fix_prompt — the remedy written as a direct instruction (retry / repair / pause and ask your human) — and next_actions, the same recovery as a typed, best-first menu. Exit codes: 0 success · 1 retryable (network / 429 / 5xx / 402 billing / job still running) · 2 auth (401/403) · 3 validation (400/404/409/422 or a bad flag) · 130 on interrupt.

The CLI doubles as a local MCP server (stdio), backed by the service's own MCP endpoint — same auth, billing, and backpressure as the REST API:

hexstellar mcp

Tools: hxs.analyze (free preflight) · hxs.compute (solve, routed by shape) · hxs.verify (free service re-check for supported candidate properties) · hxs.inverse · hxs.explore. Cursor & friends: {"mcpServers": {"hexstellar": {"command": "hexstellar", "args": ["mcp"]}}}.

Least privilege: hexstellar mcp --read-only exposes only the free tools (hxs.analyze, hxs.verify) — hand an exploratory or untrusted agent the discovery surface with zero spend risk.

Running LangChain, CrewAI, or your own loop? Export typed tool specs in your dialect — no MCP host required:

hexstellar tools --target openai        # or: anthropic | json-schema | mcp

import hexstellar
tools = hexstellar.tools("openai")                # 3 tools: solve (billed), estimate + verify (free)
hexstellar.runtime_capabilities()                 # egress, auth class, recommended mode — measured, not guessed

• AGENTS.md (ships in the wheel) — precise operating notes: contract, edge cases, canonical workflow.
• hexstellar agent-info — the CLI's own contract as JSON (exit codes, env vars, per-command mutating/billed/dry-run facts), offline.
• hexstellar capabilities — the machine-readable manifest (every command + schema + result semantics).
• hexstellar spec — the exhaustive agent specification (fetches the latest live; --offline for bundled). Also ships as AGENT_SPEC.md.
• hexstellar prompt — a drop-in system prompt for your agent (AI_PROMPT_TEMPLATE.md in the wheel).
• hexstellar skill — the Agent Skills SKILL.md (ships in the wheel): drop it into your agent's skills directory and it knows HexStellar.
• hexstellar pricing — plans + metering as public JSON (no auth); answers past 50% of the daily quota carry a usage_alert ladder (50/80/95%).
• hexstellar examples / hexstellar example <id> — the live catalogue of verified transfer recipes, updated server-side without a reinstall; rendered at https://docs.hexstellar.com/examples/.
• hexstellar init-agent — write the agent prompt into your IDE rules file (.cursorrules or AGENTS.md).
• https://docs.hexstellar.com/llms.txt — the machine-readable front page for AI fetchers.

Cortex already uses HexStellar acceleration when supported problems execute on HexStellar-managed infrastructure. Enterprise is the other deployment path: a licensed customer-deployed runtime for compatible computation in the customer's own applications, frameworks, model-serving/LLM stacks and other workloads.

• License and NDA required. Evaluation is arranged directly with HexStellar; there is no public automatic approval.
• No public runtime download in 1.0. enterprise request records interest, while setup and activation remain fail-closed until HexStellar issues an approved package and license.
• Campaign-scoped evidence. Energy, temperature, throughput, capacity and latency measurements are reported only with the hardware, workload, denominator, correctness scope, date, limitations and evidence that produced them.
• Live truth, not stale marketing. Run hexstellar enterprise status to read current availability, scope, evidence and next actions from the published runtime manifest.

For licensed evaluation, research collaboration or deployment discussion, visit https://hexstellar.com/#contact.

This package is a thin client: it contains no solver. It packages your request, sends it over HTTPS with your key, and prints the reply. Zero dependencies (standard library only), standard TLS, and it warns before ever sending a bearer token over plain http://. There is nothing here to reverse-engineer — the client is a transparent transport.

The wheel itself is built to be trusted by machines that check, not just humans that hope:

• PyPI Trusted Publishing (OIDC) — no long-lived tokens anywhere in the release path.
• SLSA build provenance attested at build time.
• PEP 740 attestations recorded on the published distribution.
• Wheel content guarded by an allowlist in CI — the artifact contains exactly the files it should, verified on every release.

I did not begin HexStellar by asking how to build another solver for difficult problems. While I was building Trust Carbon Infrastructure, I discovered a software foundation that accelerated compatible computation and reduced energy use. Then I asked a different question: what if I applied that discovery to mathematics, simulation, structured decisions and verification?

That work became Cortex. An AI can interpret a human problem, adapt a computational recipe, validate the formulation and send the supported part to HexStellar. Cortex executes it on our accelerated infrastructure and returns the result, measured cost, receipt and assurance. The Enterprise runtime is the customer-deployed expression of the same platform for compatible compute paths under a separately issued licence and NDA.

The engine behind this CLI is proprietary. What its public contracts do is measurable: they take a precisely stated problem, return structured results and cost metadata, and label assurance explicitly. Free service re-checks are available for supported properties; local recomputation, formal proof, and domain checks are separate classes. Enterprise runtime evidence is campaign-scoped, and verification packages that are not public are identified as available only through the NDA evaluation process.

The agent-first advantage is visible in the workflow: an AI reads the live contracts, adapts a recipe, adds the user's own constraints, validates, estimates, executes within authorization, and applies the declared assurance and verification path. Work that used to require a custom integration becomes a structured subroutine, without implying that every formulation fits or that every returned result is formally proven.

The long-term direction is to move qualified computation closer to where it is needed — including local, offline, edge and constrained systems — without pretending that every workload, device or assurance class is already supported. That is the only kind of bold claim worth making: the falsifiable kind. If this is useful to you, hold us to it. Run the examples, verify the answers, measure the memory and time in your own workload, and tell us where the numbers should be better.

— Brayon Pieske, founder

The public 1.0 workflow fits in four commands and needs no signup for a sandbox-sized test:

pip install hexstellar
hexstellar demo
echo '{"n":4,"edges":[[0,1,1],[1,2,1],[2,3,1],[3,0,1]],"description":"split a 4-node ring network into two groups cutting the most links"}' | hexstellar solve maxcut
echo '{"problem":{"n":4,"edges":[[0,1,1],[1,2,1],[2,3,1],[3,0,1]],"description":"split a 4-node ring network into two groups cutting the most links"},"answer":[1,0,1,0]}' | hexstellar verify maxcut

• Found a rough edge, a confusing error, a doc gap? Use hexstellar report create (bounded reports are on by default; inspect with report status, preview with --dry-run, or opt out with report off) or write to support@hexstellar.com. Reports carrying the RFC 9457 code are especially useful.
• Want to go past sandbox scale? Register a free key and re-run at full size.
• Browse the live transfer recipes at docs.hexstellar.com/examples — copy one, adapt the formulation to your data, and run it.

1. Run the quickstart above — no signup, no key, sandbox-sized, runs verbatim.
2. Browse the live worked recipes at https://docs.hexstellar.com/examples/ — copy one, adapt it to your data, and run.
3. Register free at https://hexstellar.com for full scale, then hexstellar login.
4. Wire your agent — hexstellar mcp, or hexstellar tools --target openai|anthropic, or hexstellar init-agent.
5. Watch the service live at https://status.hexstellar.com · health probe: https://api.hexstellar.com/api/v1/health · package: https://pypi.org/project/hexstellar/.

No. The hexstellar package on PyPI is a source-visible thin client — pure Python you can read — shipped under a proprietary license, and the solver engine behind it is sealed and never distributed. What is fully public: the docs, the input schemas, the agent specifications (AGENT_SPEC.md, llms.txt, AI_MANIFEST.json), and a live catalogue of runnable transfer recipes. The method stays proprietary; each supported result property declares its assurance and applicable service, local, formal, or domain check.

No. HexStellar Cortex is an optimization and decision service: you submit a precisely described problem as JSON and receive an answer, a certainty label, execution metrics, and a receipt. It generates no text and replaces combinatorial search, never reasoning or proof. Language models formulate supported problems from user requirements; Cortex executes them.

Yes. With no key configured, every call uses the public anonymous sandbox — small problems, rate-limited, free by design, and the sandbox token is not a secret. pip install hexstellar && hexstellar demo works with zero signup, zero config. For real workloads, register a free key at https://hexstellar.com and run hexstellar login.

Every answer carries a certainty label: certified optimum (proven by exhaustion) means the stated finite certification basis closed; heuristic means a candidate, not a proof. hexstellar verify is a free service re-check of supported properties. Treat local recomputation, formal proof, and the user's domain check as separate evidence and require whichever class the decision actually needs.

Yes — agents are the primary users. hexstellar mcp exposes a local MCP server over standard I/O, and hexstellar tools --target openai|anthropic|json-schema|mcp exports typed tool specs for any framework with no MCP host required. hexstellar agent-info returns the CLI's own contract as JSON, every error is an RFC 9457 document with an agent_fix_prompt addressed to the agent itself, and exit codes are semantic (0 success, 1 retryable, 2 auth, 3 validation).

HexStellar's public differentiation is contractual: one JSON-in/result-out Cortex surface reports the current command set through hexstellar capabilities, every result carries an assurance category, and supported properties have an explicit re-check path. The thin client has zero Python dependencies and a no-signup sandbox path. Enterprise measurements remain tied to the exact campaigns and evidence named by hexstellar enterprise status; do not extrapolate them to other hardware, models, or workloads.

Testing is free: the anonymous sandbox needs no account, and registering at https://hexstellar.com issues a free key for real work. Live plans and metering are public JSON — hexstellar pricing or GET /api/v1/pricing, no auth required. Verification (hexstellar verify) and preflight (--dry-run) are always free, identical re-runs never bill twice, and --max-compute-units caps spend by refusing to solve past your budget.

Yes: the same canonical input, the same seed, and the same model version yield the same result and receipt — same input, same seed, same answer. Model versions are frozen like LLM releases: pin cortex-1.0 and its math is byte-stable forever, or use cortex-latest for the newest stable model. Every response echoes the resolved version, and an unknown version is a clean error, never a silent switch.

Hard, large combinatorial and decision problems: max-cut, QUBO/Ising optimization, TSP routing, QAP assignment, MILP, k-of-m selection, ranking from pairwise comparisons, business-rule feasibility, set cover, coloring/design, XOR-SAT, plus spectra, extreme-precision arithmetic, lattice reduction, and integer relations. It replaces search, never proof, and never text generation. Run hexstellar capabilities for the current machine-readable list with exact input schemas.

It never presents an offline sample as a live solve, and never fabricates an answer it could not send.

No. The package is a thin client containing no solver: it packages your request, sends it over HTTPS, and prints the reply — all solving happens on the service, and the public agent card at GET /.well-known/hexstellar-agent.json states this contract. In an air-gapped sandbox, hexstellar demo still succeeds by returning a bundled, precomputed, engine-verified prior result, honestly labeled offline_precomputed — never a simulation.

Every API call tells the CLI the latest published version; if yours is older, an upgrade hint prints to stderr (never stdout, so machine output stays clean):

pip install --upgrade hexstellar

If a number in this README looks too good — run the command next to it. Every "maybe" here becomes a test and a number.

© 2025–2026 Brayon Pieske — HexStellar. All rights reserved. Proprietary; see LICENSE.

BRAYON PIESKE — "Customer trust grows when results include clear verification and reproducible evidence."