Software Design & Systems Development, The Grocky Way
Most AI products start with a demo. Ours start with evidence. Every product runs through a governed program where each requirement traces back to a source and each major decision is recorded.
Evidence First
We research an industry into a graded evidence corpus before writing a line of code.
Framework First
Every product is built as a consumer of the shared Grocky Framework, never as a one-off.
How It Works
Six stages take a product from an idea to certified production. The first product in an industry is slower; every product after it is faster, because the platform keeps growing while the industry layer stays thin.
Discover
Research the industry into an evidence corpus: sources graded by strength, claims linked to sources, open questions tracked as hypotheses.
Model The Business
Map value streams, capabilities, processes, rules and events, and mark which work AI can augment and which must stay human.
Specify
Write atomic, testable requirements traced to capabilities and evidence, each tagged platform-reusable or industry-specific.
Architect
Record each design choice (service boundaries, data, AI, tenancy, deployment) as an architecture decision before code is written.
Build As A Consumer
Build the industry product on top of the platform, milestone by milestone, with reusability guardrails gating every merge.
Preview, Certify, Operate
Ship in preview, have domain experts validate the knowledge, promote to production, then monitor quality and cost continuously.
Six Layers, One Direction Of Dependency
Platform layers know nothing about any industry. Industry layers build on the platform, and never the other way round. That one rule, checked automatically on every commit, is what lets a new product start half-built.
Industry Products[V] vertical
Knowledge Packs & Connectors[V] vertical
Capability Services[P] platform
Intelligence Layer (AI OS)[P] platform
Platform Core[P] platform
Infrastructurefoundation
Platform Core
Identity, role-based access, tenancy, an append-only audit trail, documents, workflow and billing: built once, tested once.
Intelligence Layer
The framework's AI operating system. Products submit AI tasks; this layer handles retrieval, generation, citations, confidence, cost and review.
Capability Services
Reusable engines for deliverables, documents, spatial analysis and field capture, with no industry vocabulary inside.
Knowledge Packs
An industry's expertise as data: versioned claims tied to source, jurisdiction and effective date. New industry, new packs, same code.
Connectors
A standard plugin contract (authorize, sync, map, report health) with licensing enforced where data enters.
Industry Products
Thin consumers of everything below: their own templates, roles, packs and screens, from their first commit.
Built On Deep-Learning Infrastructure
Underneath the intelligence layer are the deep-learning models that make modern AI possible. Our job is to make them dependable: grounded, measured, auditable and replaceable.
Transformer Foundation Models
Frontier models from leading providers paired with open-weight models on our own GPU hardware, chosen per task by quality, cost and data sensitivity.
Embeddings & Semantic Retrieval
Neural embeddings turn regulations and documents into vectors. Retrieval runs on pgvector inside each tenant's database, behind a service built to swap engines without rewrites.
Document, Speech & Vision Models
OCR and vision read scanned contracts and forms. Speech models transcribe meetings. Their output feeds the same citation pipeline as text.
A Governed Model Gateway
One OpenAI-compatible gateway routes every request, with provider fallbacks, per-tenant budgets and metering.
One Contract For Every AI Task
No product talks to a model directly. Production results without citations, confidence and provenance are rejected by the framework. Human-gated tasks return a recommendation, with no "decision" field for software to fill.
# AI Task Envelope (in) { "task_class": "section_draft", "tenant": "t_4821", "prompt_ref": "deliverable/section@v3", "evidence_query": { "pack": "ceqa" }, "grounding_mode": "production", "budget": { "max_usd": 0.40 } } # AI Result Envelope (out) { "output": "…", "citations": ["corpus://source/SRC-0042#CLM-0017"], "confidence": 0.86, "review_status": "pending_review", "cost": 0.07 }
The Six-Step Grounding Pipeline
Every AI task in every product passes through the same six steps. Skipping one isn't a setting anyone can change.
Retrieve
Only claims the task may use, filtered by jurisdiction, date and validation status.
Assemble
A versioned, governed prompt built from the template and evidence.
Generate
The gateway routes to the right model, or compares several, within budget.
Bind
Citations, confidence and provenance attached; every citation must resolve.
Check
Quality monitoring scores the result and flags gaps and drift.
Route
Human-gated results go to a named reviewer; everything is audited and costed.
Production Uses Only Expert-Reviewed Knowledge
Every claim in a knowledge pack carries a validation status. Production output may only be grounded in claims domain experts have reviewed or certified. Everything else runs in a clearly labelled preview mode, which is how a product can be demonstrated honestly before its knowledge is certified.
Claims can also be Hypothesis, Disputed, Deprecated or Superseded. Conflicts between sources are preserved, not silently resolved.
The Software Never Signs
Where a deliverable moves through a lifecycle (draft, internal QA, certified, submitted, under review, accepted) the framework enforces the gates structurally:
- Certified requires completeness, every citation resolving and no open QA items
- Certification requires a named individual; the platform never certifies itself
- Open reviewer comments block resubmission
What The Framework Guarantees
Evidence Over Assertion
If the AI can't cite it, the framework won't present it as fact.
AI Recommends, People Decide
Judgement and sign-off belong to named, accountable professionals.
Isolation By Design
Each customer's data in its own database; four-tier data classification enforced in code.
Reusable By Construction
CI fails the build if platform code references an industry or calls a model directly.
Model-Agnostic
One gateway and one contract, so better models drop in without touching products.
Cost-Aware
Every AI job budgeted, metered and attributed to a tenant.
Secure From The Platform Up
- Database-per-tenant isolation on PostgreSQL
- Append-only audit across every service
- Secrets stored outside the reach of AI agents and their tools
- Administrative access only over a private mesh network
- Default-deny firewalls and automated intrusion blocking
- SSO / MFA, backups and disaster recovery in the platform core
Proven, Replaceable Technology
Technology choices are recorded as architecture decisions and treated as the most replaceable part of the system.
See It Working On Your Problem
Tell us about your workflow and we'll set up a demo with the product that fits, or tell you honestly if we don't have it yet.