Enterprise Ops · AI-native Knowledge & Proposal Intelligence
One AI copilot that works a bid end-to-end — grounded in everything your firm already knows.
OpenLi OpenBid turns a professional-services firm’s years of proposals, case studies, methodologies and CVs into a living, governed capability. When a bid arrives, the agent finds what the firm already knows, surfaces the right people, and assembles a cited first draft in hours, not days — working alongside the bid lead, step by step, always showing what it did, what it’s grounded in, what’s walled off, and how good the output is.
Three interchangeable agent runners — OpenLi Codex, the OpenAI Codex SDK, and the Claude Agent SDK — share one governed tool surface (hybrid RAG over the corpus + a derived expertise graph) behind a 4-dimension access-control filter applied before the model sees anything. Grounded or it escalates; human-gated at the decisions that matter; measured at every step.
v0.2.20 · live
Unified 3-runner architecture
Hybrid RAG + derived expertise graph
4-dimension access governance
Per-step evaluation gates
A firm’s edge is what it knows — but that knowledge is trapped.
Knowledge is scattered across SharePoint and local drives, CV / expertise data goes stale in a CRM, and there is no shared research repository. When a bid lands, proposal teams spend 60–70% of their time searching for content to repurpose, and credible-but-lost opportunities cost the firm millions a year. OpenBid closes that loop — the way a trustworthy colleague would: grounded in the firm’s own entitled work, governed by access and conflict rules, auditable, revisable at any point, and measured at every step.
Grounded in your own work
Hybrid retrieval — dense pgvector cosine and a BM25-lite keyword pass, fused with reciprocal-rank fusion — finds reusable content by meaning and by exact term. Every claim cites the entitled passage it came from; the agent escalates rather than fabricates.
Governance in the data, not the prompt
A 4-dimension access filter (tenant · clearance tier · entitlement groups · conflict-of-interest walls) is pushed into the retrieval query — the model never sees what a persona isn’t entitled to. Competitor “Chinese walls”, restricted material and stale intel are enforced structurally.
Measured, not asserted
Every agent step is scored against frozen gold ground-truth — intake accuracy, retrieval recall, groundedness, faithfulness (an LLM judge), governance-leak rate, deliverable completeness. The release is blocked if any metric drops. The agent can only get better, never silently worse.
How a bid gets worked — end to end, grounded, quantified
A bid is its own governed workspace (inputs / working / outcomes) with per-bid
access control. The agent guides it step by step — and every step has a quantified
pass/fail, with the bid lead in control at the decisions that matter.
1. Intake
Upload the client RFP/ITT package; the agent extracts the requirements, the submission checklist, the deadline and the page limits — deadline & page-limit matched exactly.
2. Research & retrieve
Ask anything; the agent searches the firm’s entitled knowledge (hybrid RAG) and the expertise graph, and answers grounded and cited — with a governance-leak rate of zero.
3. Draft
Each proposal section is composed from entitled material with inline citations and a reuse rate — grounded-or-escalate, with competitor walls enforced. Faithfulness is judged ≥ 0.7.
4. Deliverables
Real office documents — proposal DOCX, commercials & answered questionnaire XLSX, pitch PPTX — generated into outcomes/, previewable in-app, each grounded and governed.
5. Review & revise
Click any citation to peek the governed source. Revise any section on instruction — re-grounded, saved as a new version, with a diff. The agent asks a precise question when it needs one.
6. Submit
A completeness gate ensures every mandatory deliverable is present before the package is built — and the whole trail is audited (who did what, when, how it was governed).
See it live — the Ashford Partners bid lifecycle
The reference scenario is Ashford Partners, a 2,000-consultant management consultancy (the Kubrick Group case study). A heavyweight firm-knowledge corpus, a 24-consultant expertise graph, and worked bids (Northwind Bank, Brackenfell Power, Calder Health) — plus three planted governance traps that prove the guardrails hold.
Live URL
bid.openli.ai · sign in as a persona and watch a bid progress from intake to a cited, governed submission package. Real grounding on text-embedding-3-small + pgvector.
Governance you can see
Run the same query as different people: a bid lead is walled from a competitor (Sterling Union); a practice lead is entitled to restricted material (Helios) a partner is not; stale 2019 intel is flagged on access. Access control is enforced before retrieval.
Assurance, in the open
An evaluation page shows the per-step quality scorecard with a release-over-release, no-regression gate; each bid carries an in-workspace quality banner and an audit trail. Every agent call shows its real token / fee.
Audit defensibility & non-functional posture
The same governance posture every OpenLI product inherits from the OpenLI Codex foundation, tuned for the professional-services buyer who lives and dies by trust.
Grounded-or-silent
No fabrication: every claim cites an entitled, retrieved source, or the agent escalates. A RAGAS-style LLM judge scores faithfulness; good-vs-bad answer pairs meta-test the judge itself.
Access control in the query
The 4-dimension ACL filter is part of the SQL WHERE, not a prompt instruction — tenant, clearance tier, entitlement groups and conflict walls. Confidential / competitor / PII docs are blocked before the model is invoked. Governance-leak rate: held at 0.
Human-in-the-loop
Three points of control: the agent asks a precise question when it needs one; nothing client-facing is finalised without explicit approval; and any outcome can be revised on request — all audit-logged.
Provider neutrality
One governed contract from OpenLi Codex (the default, ~64× cheaper in A/B), the OpenAI Codex SDK, and the Claude Agent SDK. Per-bid runner toggle, real token / fee metering. No vendor lock-in.
Release gates
Build · health + reindex · backend acceptance (22 use cases) · frontend Playwright (69) · per-step lifecycle gold eval (release-blocking) · submission-quality gold — all green, with a no-regression bar before anything ships.
Operational maturity
8-service Docker Compose on ports 9410–9419, live on the AWS shared VM sibling to OpenSOP, OpenCT, GSJ and OpenMPI. Sequential-build deploy with health smoke between services; per-bid RBAC; full audit trail.
Three generations of agent paradigms — in one product
No single agent paradigm is best for every call. OpenBid lets you pick the right runner per cost / latency / autonomy profile, with the same grounding, governance and HITL applied to all.
1st gen — RAG
Chunk + embed + retrieve. Deterministic, citation-friendly, can’t plan. OpenBid keeps RAG as a governed tool — hybrid dense + sparse retrieval, ACL-filtered — not the whole agent.
2nd gen — LangGraph-era
Hard-coded DAGs over LLM calls. Predictable, but brittle when the work evolves. We’ve deliberately moved past this paradigm; mentioned for completeness.
3rd gen — autonomous agents
File-aware agents that plan and execute, coworking on a live bid. OpenLi Codex, the OpenAI Codex SDK and the Claude Agent SDK represent this paradigm — with grounding, ACL and HITL as the difference over a raw agent loop.
Sister products in the OpenLI family
OpenBid shares the same OpenLI Codex foundation, the same agent runtime, the same governance posture and the same audit story as every other OpenLI product. One security review covers the whole portfolio.
OpenLI Codex foundation
The agentic runtime that powers OpenBid’s unified 3-runner, OpenSOP’s triple-runner, OpenMPI’s rationale layer and every other OpenLI product. One security review covers all.
OpenSOP
OpenBid’s closest sibling in Enterprise Ops — OpenBid was forked from it. AI-native SOP automation and purchase-order exception triage; same runner pattern, same governance and audit discipline.
OpenCT
Sister 3rd-gen product in Finance & Compliance. UK Corporation Tax filing direct to HMRC. Same governance and runner pattern; explains the platform’s sector neutrality.
OpenTrials
Sister 3rd-gen agentic product in the Pharma cluster. Risk-based monitoring for clinical trials — same Claude / OpenAI runner pattern, same audit-trail discipline.
OpenMPI
Sister 3rd-gen product in Healthcare. AI-rationale-assisted Master Patient Index — the same “AI proposes, human decides” pattern OpenBid uses for approvals.
GSJ Platform
Sister partner-led reference deployment, in Travel & Experience. Different sector; same foundation, same lifecycle gates, same operational discipline.
Where OpenBid is today — and what’s next.
v0.2.20 is live on AWS at bid.openli.ai, sibling to OpenSOP, OpenCT, GSJ and
OpenMPI. The Ashford Partners scenario is the reference; the platform is gated green across the
full release ladder on every release.
Live in v0.2.20
Per-bid governed workspaces · unified 3-runner · hybrid RAG (dense pgvector + BM25-lite, RRF) · derived expertise graph · 4-dimension ACL + conflict walls + freshness · grounded-cited drafting · real DOCX/XLSX/PPTX deliverables + in-app preview · revise & versioning · agent clarifying questions · in-workspace audit trail · per-step evaluation (Gate 4 + 4b) · live ingest + live graph update.
Coming next (0.3.x)
Multi-hop expertise-graph traversal (Apache AGE, openCypher) · proactive freshness surfaced onto open bids · routing curation / ingest through the backend RBAC boundary · performance and accessibility gates.
Beyond
Knowledge & Proposal Intelligence beyond consultancies — any firm that bids, tenders or proposes from a body of prior work. Same foundation, sector-tuned corpus and governance per tenant.
ENTERPRISE OPS
Ready to see the AI copilot work your bids?
OpenBid is in active development toward a production product; we are prioritising professional-services firms with a deep body of prior work and a real bid-throughput pain point. Talk to the team about your knowledge corpus, the governance you need, and whether OpenBid fits the next 12–24 months of your growth.