AlphaCore — Fyboard's contract lifecycle platform
AlphaCore is the records-first surface for contract operations. Authoring, e-signature, obligations, compliance, workflows, repository, and search are all built on the same engines — every clause is structured operational state.
Capabilities
- Contract Authoring — Draft, version, redline, and execute contracts as governed records — not Word documents in folders.
- E-Signature — Signing as operational activation, not a terminal event.
- Smart Obligations — Contracts as live operational entities, not reminders.
- Compliance & Risk — Continuous compliance, audit-grade evidence, and principle-driven controls.
- Workflows — Contracts don't execute themselves. AlphaCore workflows do — with audit-grade state.
- Universal Repository — The contract system of record — a system that remembers, governs, and explains.
- Search & Discovery — Semantic search across contracts — keywords, structure, and explanations together.
See pricing or compare AlphaCore at /alphacore/compare.
Where contracts live,
not just where they're
stored.
AlphaCore turns every contract into a governed, living record — with obligations anchored to source paragraphs, state changes attributed to people, and a complete audit history that runs to the moment of signature and beyond.
“The Service Provider shall maintain valid insurance coverage of not less than $5,000,000 and provide certificates evidencing such coverage annually…”
The system that managed the document steps aside at the moment the contract starts mattering.
Three failures compound after signing. Each one is a consequence of treating the contract as a file, not a record.
Contracts break after signing, not before.
Most systems treat signing as the finish line. In reality, signing is when the contract begins to matter.
After execution, obligations activate. Timelines start running. Money moves — $340k of penalty exposure accrues silently. Responsibilities shift. The system that managed the document up to signature steps aside the moment its work would actually count.
Contracts don't fail because they're poorly written. They fail because they stop being managed.
Documents are static. Contracts are not.
A document captures text at a moment in time. A contract lives across years — years, not minutes of state changes, amendments, party rotations, renewals.
The document can tell you what was agreed. It cannot tell you what is active, what is pending, what has changed, or what is at risk right now.
Only by treating the contract as an operational record — not a file — can a system reason about its present state.
Responsibility dissolves after execution.
Before signing, contracts have clear ownership. Legal authors. Counterparties review. Stakeholders approve.
After signing, the same contract appears across 7 surfaces and belongs to none of them. Email threads. Slack messages. Calendar invites. Spreadsheets. ERP entries. Drive folders. Signed PDFs — every reference, no source.
The questions that follow have no answer holder. That gap is where risk lives.
These aren't feature gaps. They're the consequence of not governing the contract as a record. AlphaCore is the system that does.
One record. Four modules. One platform.
AlphaCore doesn't ship with integrations — it ships as a citizen of the platform. The contract record below isn't a single object; it's a row joined across four modules of shared substrate.
“§4.2 — Service Provider shall maintain insurance of $5,000,000 delivered annually…”
That isn't a feature claim. It's an architecture.
A contract isn't a document. It's four governed objects that move through time together.
Lifecycle. Parties. Decisions. Obligations. Each is a first-class record. Each has its own state, owner, and audit trail.
What looks like a contract on a screen is, underneath, a small constellation of governed records joined to one another.
Lifecycle
An explicit set of states the contract moves through.
Parties
Everyone the contract binds, references, or empowers.
Decisions
Every authorized choice that shaped the contract.
Obligations
Every commitment the contract creates, by whom, by when.
What it actually means to approve a contract.
One contract. One transition. Negotiation → Approved. Below is every record AlphaCore writes when that single state change happens — and what becomes possible, and impossible, the moment it does.
- The signature workflow can begin
- Counterparty receives signing link with exact approved version
- Obligation drafts attach to the record (provisional, not yet active)
- Renewal clock primed for activation upon signing
- Further redlines without re-entering Negotiation state
- Approval by anyone outside the recorded delegation chain
- Quietly rolling back without leaving a forensic trail
- Backdating any decision recorded in this transition
A state change in AlphaCore is a record you can audit, not an email someone sent.
Ask the contract what was true last March, and the system answers.
Most systems remember what changed. AlphaCore remembers what was true — at every recorded moment, alongside who knew what, who could act, and what the system would have done if asked.
Once contracts are governed as records with state, authority, and memory, they stop being passive documents. They become operational.
See it across the lifecycleAlphaCore wasn't built for hypothetical customers. It was built for one we know intimately, and deployed there long before we shipped a public version.
18 months of real contracts. Real states. Real obligations tracked, missed, satisfied. Refined inside an Indian infrastructure enterprise running a portfolio at ₹2,500cr+ scale.
The kind of proof you only get from running the system on contracts where the consequences are real.
Numbers reflect production state as of Mar 2026. The deploying entity is referenced as “the operator” below — identifiable details are withheld at their request, but the system, the records, and the operational scale are real.
An insurance certificate that was missed for 47 days on the previous system. AlphaCore caught the next one with 90 to spare.
One ₹140cr EPC contract. Two annual obligations: insurance certificate refresh, performance-bond renewal. Both buried in §4 and §11 of the master agreement. Both scheduled to recur every year. Both forgotten in spreadsheets the year before AlphaCore went live.
On the AlphaCore-managed cycle, the obligations were extracted at the moment the contract was uploaded — anchored to source, owned by the named compliance officer, and surfaced as work, not as text. The system fired at 90, escalated at 30, and satisfied at 14.
“The Contractor shall maintain valid insurance coverage of not less than ₹14,00,00,000 and provide certificates evidencing such coverage annually…”
Every line of AlphaCore was written knowing that the next contract it would touch would be one I knew about personally — and would answer for if it broke.
We didn't build AlphaCore to sell to companies like ours. We built it because we needed it ourselves, and could no longer pretend that running a multi-entity operation on spreadsheets and email threads was acceptable. The public version exists because what we built worked, and we think the same problem exists in your operation.
Most CLM products promise what their roadmap says. AlphaCore promises what production says. Every feature you've seen on this page is currently managing real contracts at real scale — not in a sandbox, not in a demo instance.
One record. Five lenses. The same truth, surfaced for the work each role actually does.
Legal sees the redlines and the authority chain. Finance sees the payment schedule and the caps. Operations sees obligations as a queue. Risk sees the breach surface. Executive sees the portfolio position. Same record. Same database. Different projection.
Permissions follow the lens — not the other way around.
— The clause, the redline trail, the authority chain — and the obligations Legal owns.
“The Service Provider shall maintain valid insurance coverage of not less than $5,000,000 and provide certificates evidencing such coverage annually…”
A lens is not a separate copy of the contract. It's the same record, projected. When Risk acknowledges a regulatory trigger, Legal sees that decision in their authority chain. When Finance marks a milestone paid, Operations watches the obligation close. The lenses look in. The truth is one.
How permissions actually workFor the careful reader who's still here
Most CLM pages end with a feature matrix. We'd rather end with an argument — and one honest admission.
Other CLMs are tools you bolt onto your stack. AlphaCore is part of your stack. That difference cascades through every claim on this page — from how obligations get extracted, to how permissions inherit, to how a state change becomes a record you can audit, not an email someone sent.
They are standalone products.
AlphaCore is a platform module — sharing one database, one identity model, one audit log with the rest of Fyboard.
They sell features. We earn trust by shipping architecture.
Repository, obligations, audit, access, versioning — these aren’t features we built. They’re consequences of the underlying record model.
They will ship anything to win the demo.
We won’t. We’d rather ship the layer underneath right than ship the layer on top fast. Some features take longer because of this.
Authoring isn't shipped yet — negotiation-grade drafting and clause assembly. It's on the road map. We'd rather ship this part right than ship it all early. Until then, you bring the document and AlphaCore governs everything that happens to it after.
One contract. Seven days. From upload to first obligation firing — what the path actually looks like.
We'll walk through it minute by minute, on a real contract, with real timestamps. The point isn't to show off the product — it's to remove the ambiguity about what changes on the day you go live, and the days after.
You upload the contract.
One drag, one drop. The record is created before you let go.
You drag the contract in. AlphaCore creates a record, hashes the source, and assigns it a permanent ID before anyone sees it. From this moment, every change is recorded against this ID.
FyBrain reads it.
Clauses, obligations, and risk surface in seconds — each anchored to its source paragraph.
You review what was extracted.
Human in the loop. Nothing goes live without your sign-off.
"…shall maintain valid insurance coverage of not less than $5,000,000 and provide certificates evidencing such coverage annually…"
"…the Service Provider shall submit performance metrics within 15 days of each quarter end…"
"…the Parties shall consult in good faith on material changes…"
— You see what was extracted, what FyBrain's confidence was, and the source paragraph it came from. You accept, edit, or reject each one. Nothing goes live without your sign-off.
You assign owners.
From your existing team directory — not a separate AlphaCore user list.
The system goes live.
Alerts armed. Audit chain anchored. Renewal flagged.
The first obligation fires.
In someone's queue, with the source clause and the deadline.
Insurance certificate refresh — due in 90 days
Certificate of insurance covering the next 12-month period. Source clause requires $5M minimum. Last cycle landed 14 days before deadline — comfortable buffer.
Seven days after upload, the system fires the first obligation. Not an email someone wrote. Not a calendar reminder someone set. A piece of governed work, surfaced where work happens.
Bulk import keeps history.
Existing contracts come in with versions, decisions, and obligations preserved. Previous-system audit trails get attached as evidence rather than replaced.
Permissions inherit from your team directory.
Roles, delegations, and reporting lines come from the team directory you already maintain — already configured, already kept current. No separate AlphaCore user list to provision.
It's already integrated.
FyDrive holds the source files. The team directory drives ownership. FyTask receives the work. FyCal flags the renewals. No external connectors to set up.
Seven days from upload to live obligation. Add a few more for the second contract, fewer for the tenth. The path is short because the system already knows your people, your folders, and your work.
Built for the infosec questionnaire, not the sales call.
The biggest difference
Your contracts don't leave the country. Neither does the AI that reads them.
FyBrain handles extraction, embeddings, and analysis inside the Indian region — no third-party LLM providers, no cross-border calls. The platform itself sits in Mumbai. External services see only encrypted transit. DPDP-aligned by construction.
AES-256 at rest. TLS 1.3 in transit.
Database, backups, and inter-service traffic — all encrypted with rotating keys.
Permissions enforced at the data layer, not the app.
A 4-tier monotonic grant model enforced at the database layer. Fail-closed by default — the application can't override what the data layer denies.
Every state change is a tamper-evident record.
Hash-anchored, append-only, separately verifiable. The audit log is itself an artefact.
The full security packet — DPA, sub-processors, diagrams, pen-test summary — available under NDA.
Contract infrastructure. No surprises.
Per-owner pricing. Editors manage contracts. Viewers — auditors, stakeholders, exec dashboards — read for free, always.
Free
· always free1 contract · 5 AI jobs/mo · 1 GB Drive · 3 editors + unlimited viewers
Solo
— Professional contract management
save $480/year
- 2 active contracts
- 5 GB Drive + e-signatures
- 30 AI processing jobs/month
- Full Gmail integration
Growth
— Full contract operations
save $1,200/year
- 3 active contracts
- 25 GB Drive + full insights
- 100 AI jobs + portfolio calendar
- Read-only API access
Scale
— Scaling contract portfolios
save $3,600/year
- 10 active contracts
- 100 GB Drive + RBAC
- 500 AI jobs + batch processing
- Full API access
Business
— Enterprise-grade CLM
save $10,800/year
- 50 active contracts
- 500 GB Drive + webhooks
- 2,000 AI jobs (priority queue)
- 3-year audit + dedicated onboarding
Enterprise
— Mission-critical infrastructure
$8,000 – $50,000/mo
- Unlimited everything
- SSO / SAML / SCIM
- Multi-org & on-premise options
- Dedicated account manager
Add-ons, competitor pricing analysis, and the line-by-line tier comparison — including how AlphaCore stacks up against Ironclad and Icertis on per-seat math — live on the full pricing page.
The questions we hear from buyers, with the answers we'd give over coffee.
No collapsible accordions, no hidden objections. If you're asking it, someone before you has asked it — and we'd rather you read the honest answer here than wait for the demo call.
Adoption & migration
— How you actually get on, and how you bring what you already have.
How is this different from just using Notion + Google Drive + a shared calendar?
We don't replace those — we sit on top of them with structure. Notion is great for documents, Drive for files, calendars for time. None of them know what an obligation is, who owns it, what clause it came from, or whether it was satisfied. AlphaCore is the layer that turns those tools into a contract operation.
How does migration from Ironclad, Icertis, or SAP CLM work?
Direct import from incumbent CLMs isn't shipped yet — we're building structured importers for these specifically because every export format is different and bad migrations are how trust gets lost. In the meantime, we'll do supervised migrations as part of enterprise onboarding — your team exports, we map the schema, contracts come in with their version history and audit trail attached as evidence. Talk to us; we'll be straight about what works today and what we'll build for your shape of data.
What's the realistic implementation timeline for a real org — not the 7-day demo?
It depends on portfolio size, document quality, and how clean your existing folder structure is. The 7-day demo in §07 is real, just for one contract — your full portfolio takes longer because each contract needs review, owner assignment, and permission scoping. We'll scope this honestly during your pilot — sample your contracts, walk through the path, give you a calibrated estimate before you commit.
Operations & limits
— The practical questions about day-to-day use, integrations, and what isn't here yet.
E-signature — do you integrate with DocuSign, or do you have your own?
We have our own. FySign ships as part of FyTools — included free with every tier, no separate module. Sign requests fire from the contract record, signatures land back on the same record, and the audit chain anchors the signature event automatically. Bulk sign-out flows, custom routing, and conditional signer chains live in the Automation module. We didn't see a reason to ask you to pay DocuSign for something that's already part of your platform.
Authoring isn't shipped yet. What do we use for drafting in the meantime?
Whatever you use today — Word, Google Docs, your law firm's templates. AlphaCore picks up the contract once it's drafted. When Authoring ships in Phase 2, redlining and clause assembly become native; until then, you bring the document and we govern everything that happens to it after.
How does AlphaCore handle external counterparties — clients, vendors? Do they need accounts?
No. External parties never log into AlphaCore. Document requests, signature flows, and counter-redline cycles all happen via secure links — no account creation required. Internally, their organisation appears as a counterparty record with full history; externally, they see only what you share.
Will my Legal team complain that AlphaCore isn't a Word add-in?
Maybe at first. Lawyers live in Word, and we don't fight that — drafting still happens wherever your team drafts today, and AlphaCore takes over once the contract is ready to run. What changes their minds isn't our pitch; it's the first month of obligations being tracked automatically and decisions being recorded with hash anchors. The work AlphaCore does for them was previously theirs to do manually.
Trust & continuity
— Lock-in, ownership, and the question every honest buyer eventually asks.
What happens if we want to leave? Are we locked in?
Your data is yours. Full export at any time — contracts as PDFs, metadata as JSON, obligations as CSV, audit chain as signed JSONL. No proprietary format you can't read elsewhere. No export fee, no notice period. The lock-in we want is workflow value, not data captivity.
What if we outgrow our tier mid-contract?
You move up, prorated. No re-negotiation, no penalty. Going the other direction (consolidating after a corporate change, for instance) we'll work the math fairly — published prices are floors, not ceilings, and it cuts both ways.
Why should we trust a solo founder with our entire contract operation?
The honest version — what we tell every infosec lead, every CFO, every general counsel who asks.
Three things, said plainly. One, AlphaCore is already running our own ₹2,500cr+ portfolio — we eat what we cook, and the consequences of failure are ours first. Two, your data is exportable from day one — if the worst happens, you walk away with everything intact, in standard formats, no questions asked. Three, source escrow is on the table for enterprise contracts. We'd rather make continuity contractual than ask you to trust on faith.
The fastest way is to ask us directly.
30-minute call with the founder. No deck, no pitch — your questions, our straightest answers, walking through the product on your contracts if you want.
— you've read enough.
AlphaCore is a different kind of CLM because it's not a CLM at all — it's a contract-shaped layer of an operating system you were going to have anyway.
We built it for a real ₹2,500cr+ portfolio, and ran it there before we ever shipped it publicly. The features we haven't shipped, we haven't shipped — and we've told you which ones, on this page, before you asked. The decision is whether you want a tool you bolt on, or a layer you stand on.
30-min call
No deck. We walk through your contracts together.
Try it
Free tier or short paid pilot — your call. Real contracts, real obligations.
Decide
Continue, or take your data and walk away. No friction.
Built by people who answer for the contracts they govern.