CogSheet™HyX Private BETA Preview
Sign In
A new generation of spreadsheet formulas

Every cell,
A new possibility.

Every cell is a workload. Connect data, files, code and AI through formulas. Reuse each result—and see exactly where a workflow goes wrong.

Designed to run locally or across approved compute nodes, through the spreadsheet or its APIs. Work individually or together, turning data you choose to share into small, reusable models for everyday tasks and enterprise workflows.

Local by design. Cloud by choice. Errors remain visible.

From input to result
B2 CogSheet™ cellYour formulaInput → OutputResult or #ERR!
“Put the product specifications into columns.”=WEB.EXTRACT(A1, "product specifications", COLUMNS(B1:G1))

A web page → structured rows you can compare.

Explore the full product direction. These illustrate planned adapters, not live connections.

Every cell is a unit of work

One cell. One job.
A result you can use.

01 · InputA number, a file,
another cell
02 · FormulaCalculate, read,
predict, run AI
03 · OutputA result.
Or a visible error.
For everyday life. For the work you do.

Make everyday life
a little easier.

With the things you already use: a URL, a social feed, a photo or a voice message from a friend. Give a cell an input, describe the job and use the result in your next step. The same idea scales from a household list to a business workflow.

01 · A link

“Compare these offers.”

A shop page, a supplier catalogue or a research source. Bring the facts you need into columns.

02 · A social feed

“What keeps coming up?”

Turn a permitted feed or saved export into topics, recurring questions and useful signals.

03 · A photo

“Read this for me.”

A receipt, an invoice or a handwritten list. Extract the fields, then calculate with them.

04 · A voice message

“What do I need to do?”

A friend’s voice note or a team recording. Turn the words into a transcript and reviewable actions.

Already in this demo

100 receipts.
One small household micro-model.

From just 100 synthetic receipts, we built a small predictive model of shopping habits. It measures the gaps between purchases and uses them to suggest what may be due again.

That is a first step toward useful AI at home: a familiar question, answered from your own everyday data.

Try “What should I buy?”
INSIDE THE SAMPLE MODEL

Milk

Purchase observations
—
Typical purchase interval
—
Next purchase estimate
—

A deterministic purchase-cadence model. It estimates shopping needs; it does not measure what is left in the fridge. Training and exporting neural models are planned capabilities.

The input scenarios above describe the full product direction. This public demo uses prepared receipts and a bundled offers feed; personal uploads, live URLs and social connections are not enabled here.

Real outputs from synthetic data

Try a familiar question.

These answers are calculated from the sample household’s 100 receipts. Choose an example to load its formula, then press Run formula in the sheet. All public examples run without paid AI calls.

Live sample workbook

Every input. A next step.

This workbook is generated from a fixed seed and reference date. Every formula below runs in the CogSheet™ deterministic engine and returns the same result for the same input.

Predictive pantrypublic-demo.hyx · Read-only dataset
EXECUTIONDeterministic only
E2fxReady
6 cells computedThird-party calls: 0Target runtime: ecOS >_ CogPOSIX
#ERR · know exactly where to look

If a step fails,
the cell tells you where.

A complex formula can involve many cells, including AI. When a step fails or its output fails a check, that cell shows an error such as #MODEL!. You can identify the input, formula or model result that needs attention.

Follow a problem through the cells.

Interactive illustration · fixed sample outputs, no AI call.

A2 · INPUT

Receipt photo

Original input stays available.

B2 · AI EXTRACTION

£17.99

Expected output: a numeric total.

C2 · CALCULATION

£22.99

=SUM(B2, 5)
D2 · RESULT

Ready to use

Uses the result from C2.

B2 supplies a valid number. C2 adds £5, and D2 can use the result.

Find the cause, even in a long workflow. The intended full-workbook behavior is to mark dependent cells as blocked until the failed step is corrected and run again. The illustration above demonstrates this on a small chain.

Checks make failures visible. Invalid formats, timeouts and detected inconsistencies can become cell errors. A plausible but incorrect AI answer still needs appropriate checks or human review.

Signal-based intelligence

Know what to reuse.
Create what is missing.

Export and embed compatible specialist micro-models wherever you need them, in Open Neural Network Exchange (ONNX) format.

At the heart of CogSheet™ is the LOGFORCE LFS Model Family: AI models trained through LOGFORCE's patented signal-learning approach. Their signal-based and non-autoregressive architecture turns task-specific representations of documents, media, web content, device readings and workflow state into fingerprints for recognition and decision-making.

The LOGFORCE LFS Model Family connects each workload to the right execution path: reuse a capability, compose known steps, adapt a function or create a new one. Designed for deterministic low-latency, high-throughput decisions, it directs generation toward new capabilities and keeps proven intelligence ready for immediate reuse.

From a cell to reusable intelligence.
INPUT + TASK

Your cell's workload

Data, intended result and a clear input/output contract.

LOGFORCE LFS Model Family

Recognize through signals

Match the workload with eligible functions, models and execution capabilities.

DECISION

Choose the right path

A structured execution choice, supported by traceable evidence and clear permissions.

REUSE

Use what works.

Run a compatible, approved function or model.

COMPOSE

Connect known steps.

Combine capabilities through typed inputs and outputs.

ADAPT

Change only what is needed.

Retrieve existing code and prepare a tested new version.

CREATE

Build the missing capability.

Use an approved AI worker to prepare new code or a model workflow.

Approved models. Controlled execution.

Run existing intelligence directly. Test and approve new functions; train and evaluate specialist micro-models when the task requires them.

USE

Cells, formulas and APIs.

Compose results into the next workload, with versions and source evidence attached.

KEEP

Your specialist intelligence.

Save and export compatible code and model packages for reuse in your chosen environment.

Every approved capability makes the next task easier.

Versioned code, models, contracts and tags return to your authorized capability library. Retrieve and reuse them instead of starting again.

CogSheet™

Your workspace: cells, formulas, dependencies and specialist model workflows.

LOGFORCE

The intelligence layer: the LOGFORCE LFS Model Family, signal fingerprints and capability recognition.

ecOS >_ CogPOSIX

The target sovereign runtime: controlled local execution and approved distributed nodes.

Local by design. Cloud by choice. This cloud Private BETA previews the product being built for ecOS >_ CogPOSIX. The destination is a complete local experience with your workbooks, data, functions and specialist models under your control. You choose when to enable external processing and which approved nodes may participate.

Private BETA progressively brings this full product architecture into the workspace, from workload recognition and reusable functions to sovereign execution. The public sample demonstrates its currently available capabilities.

What does “deterministic” mean here?

Each workload declares its inputs, operation, expected output and versions. Approved results can be replayed directly. New inputs, code or model versions create a new execution identity. Non-autoregressive models produce decisions through signal recognition; validation and evaluation establish their fitness for the task.

Beyond the kitchen · full product direction

The same cells.
Whole new possibilities.

Keep the familiar rows, columns and calculations. Add formulas that process documents, audio, images, web pages, signals and models, using capabilities compatible with ecOS >_ CogPOSIX.

These are planned contract examples. Their syntax and adapters are still to be implemented; the public sheet above runs the pantry formulas today.

01

Ask for a formula in your own words

“Show bills with a missing due date.” The assistant proposes a formula for your cell. You review it, run it and use its result in the next calculation.

=TABLE.FILTER(BILLS, DUE_DATE = "")=SUM(C2:C12)
02

Designed for instant decisions

The LOGFORCE LFS Model Family uses signal-based, non-autoregressive recognition to choose what to reuse, combine, adapt or create. A concise, typed execution plan connects the workload to the capabilities ready to serve it.

=CAPABILITY.PLAN(A2, TaskContract)
03

Web research into columns

Read an authorized web snapshot, extract only the requested facts and spill schema-validated rows into named columns with source evidence.

=WEB.EXTRACT(A2, "all product specifications", COLUMNS(B1:G1))=WEB.CITE(B2:G20)
04

Documents, OCR and fields

Preserve page coordinates while turning PDFs, scans, contracts and invoices into searchable text, layouts and reviewable structured records.

=DOCUMENT.OCR(A2, "en", "layout")=DOCUMENT.EXTRACT(A2, SCHEMA("invoice"), pages: "all")
05

Audio, speech and translation

Denoise a recording, transcribe it with timestamps, identify the most frequent meaningful terms, translate it or synthesize an approved voice output.

=AUDIO.DENOISE(A2, profile: "speech")=AUDIO.TRANSCRIBE(B2, "en", timestamps: TRUE)=TEXT.TOP_TERMS(C2, 20, stopwords: "en")=SPEECH.SYNTHESIZE(TRANSLATE(C2, "en", "es"), voice: E1)
06

Vision, video and inspection

Detect, segment or measure objects in images and sampled video frames while retaining the exact frame, region and model evidence behind each result.

=VIDEO.SAMPLE(A2, every: "2s")=VISION.DETECT(B2:B120, classes: {"defect","scratch"})=VISION.SEGMENT(C2, target: "damaged area")
07

Private knowledge and language

Build permission-aware indexes across text, images and audio, retrieve relevant evidence locally and generate summaries that remain linked to their sources.

=EMBED.INDEX(A2:A500, modality: "auto", placement: "local-required")=SEMANTIC.SEARCH("termination clauses", B2, 10)=LANGUAGE.SUMMARIZE(C2:C11, format: "decision memo")
08

Forecasting, signals and security

Forecast calibrated time series, detect unusual sensor patterns and classify security events without turning a model score into an automatic privileged action.

=SERIES.FORECAST(A2:A365, horizon: 30, interval: 0.95)=SERIES.ANOMALIES(B2:B10000, baseline: "weekly")=SECURITY.CLASSIFY(C2, profile: "event-v1")
09

Code and model workshop

Generate reviewable code capsules, reuse pinned environments, prepare labelled datasets and export validated small models for governed local execution.

=CODE.CAPSULE("python", A2, lockfile: B2)=MODEL.TRAIN(A2:F500, label: F, template: "classifier")=MODEL.EXPORT(G2, "onnx")
10

And many more.

A factory for intelligent formulas: combine approved capabilities, create specialist functions and models, and keep them ready for the next task. Built on signal theory and LOGFORCE's patented technology, with non-autoregressive decision intelligence at its core.

Sensing APIs connect inputs and outputs to applications, devices and infrastructure, bringing the same intelligence into the tools and environments you use.

=MY.READ_VENDOR_FORMAT(A2)=MY.SPECIALIST_MODEL(B2)
What comes next

From personal tasks.
To enterprise workflows.

Today: a working sample, visible formulas and a small predictive model. Next: your own files, reusable code and models, and execution on your own computer.

Next

Durable workbooks

Per-user workspaces, signed uploads, artifact storage, asynchronous jobs, cancellation and execution receipts.

Local

ecOS >_ CogPOSIX bridge

Local capability discovery, signed manifests, offline replay and explicit local or hosted placement per cell.

Code

Bounded code capsules

Reviewable generated code, pinned dependencies and reusable isolated environments with no default network access.

Models

Small-model workshop

Dataset and label export, validated training templates and model-specific ONNX export where technically supported.

Fabric

Governed distributed execution

Approved-node placement, node identity, revocation, permissions and transfer accounting across a future trusted mesh.

The contributor economy · Coming to CogSheet™

Build AI. Share AI.
Earn Credits. Run for Free.

Through CogSheet™, LOGFORCE incentivizes AI production, not just consumption. Share useful functions, models and packages, set a price in φ KBSU and earn credits when others pay to use your work.

Use your earned credits to pay for LOGFORCE and CogSheet™ subscriptions, services and AI capabilities. Pricing will be shown in both money and φ KBSU.

Your credits can cover your use of the platform. How much you can use without paying money depends on what you earn and spend. Credit payments and purchases are planned; pricing will be announced at launch.

Your AI can pay for your next step.

  1. Create and shareRelease a tested function, a specialist model or a reusable package to the CogSheet™ community.
  2. Earn φ KBSUPaid executions and package purchases transfer internal credits from the user to the creator.
  3. Put your credits to workPay for services, subscriptions and other creators’ capabilities. Credit purchases will open with payments.

φ KBSU are internal virtual credits.

Private preview

What would you put
in your first AI cell?

A personal project, a team’s workflow or an enterprise process. Request private access and help shape CogSheet™.

cogsheet@logforce.com