Career Highways has released SIGN™ (Sigil Intelligence Graph Notation), a new open standard that turns enterprise policies, rules, and definitions into a structured format AI agents can read, audit, and act on. The company has also filed patent applications related to the technology and is making SIGN™ freely available under the MIT License.
As businesses move AI agents into real operations, a gap keeps appearing: agents can find information but struggle to apply company rules, respect constraints, or explain their decisions. SIGN™ closes that gap with a compact, token-efficient knowledge layer between enterprise systems and AI agents — one that can reduce representation overhead by up to 50% compared with formats like JSON, while keeping decisions governed and traceable.
SIGN™ lets organizations capture five things agents need: facts, rules, constraints, inference patterns, and provenance. The result is knowledge that’s structured, enforceable, versioned, and auditable — so an agent’s output can be traced back to the exact rule, source, and version behind it.
“SIGN™ gives organizations a governed way to declare what they know, what rules apply and what an agent is allowed to do with that knowledge,” said Liz Eversoll, CEO of Career Highways. “It is the missing contract layer between enterprise knowledge and agentic AI.”
Documentation, examples, and the codebase are available now on GitHub. Learn more at careerhighways.com.
New token-efficient format can cut representation overhead by up to 50% while keeping AI decisions governed, versioned, and traceable.
MADISON, WI — July 14, 2026 — Career Highways today unveiled SIGN (Sigil Intelligence Graph Notation) and confirmed it has filed patent applications tied to the technology. SIGN is an open standard that lets organizations translate their policies, rules, definitions, constraints, and provenance into a structured form that AI agents can read, verify, and act on. The company is publishing SIGN under the MIT License.
The launch targets a problem that surfaces as companies push AI agents from pilots into live operations: agents are good at retrieving information but unreliable at applying an organization’s actual rules, respecting its limits, or explaining the reasoning behind a decision. The underlying knowledge usually exists already — scattered across documents, systems, and governance workflows — but not in a shape agents can use consistently. SIGN sits between enterprise systems and AI agents as a compact, structured knowledge layer that fills that gap.
“AI agents are moving into production faster than most organizations can govern the knowledge those agents depend on necessitating a governance framework they can operate with,” said Liz Eversoll, CEO of Career Highways. “SIGN gives organizations a governed way to declare what they know, what rules apply and what an agent is allowed to do with that knowledge. It is the missing contract layer between enterprise knowledge and agentic AI.”
Career Highways frames SIGN as doing for enterprise knowledge what SQL did for structured data: providing a shared language. Where documents are human-readable but not enforceable, and JSON serializes data without conveying meaning, SIGN is purpose-built for agent reasoning. It lets organizations express five things — facts (definitions, properties, relationships, and domain knowledge), rules (the logic agents apply to decisions), constraints (the boundaries agents must stay within), inference patterns (when agents may draw new conclusions), and provenance (the source, version, and authority behind a piece of knowledge).
The company points to common failure modes that pure retrieval doesn’t solve: a customer-service agent locating the right policy but botching an exception, an HR agent surfacing career-pathway details while missing eligibility rules, a compliance agent citing a regulation but not the current version, or a workflow agent making a recommendation without showing which rule justified it. SIGN is built around three capabilities meant to address these — reasoning-ready knowledge that encodes rules and inference patterns rather than just generating text; governed decisioning through versioning, provenance, and auditability so outcomes trace back to a specific rule and source; and token efficiency that fits more governed knowledge into an agent’s context window at lower cost.
Releasing SIGN openly is a deliberate bet. “Foundational infrastructure wins when it is open,” Eversoll said. “SQL, HTTP and OpenAPI became durable because organizations could adopt them without locking themselves into one vendor. We believe the knowledge layer for AI agents needs that same openness.” Alongside the open standard, Career Highways plans to offer enterprise-grade infrastructure around SIGN — including registry, namespace, validation, audit, and governance systems — for teams deploying agentic AI at scale.
Documentation, examples, and implementation guidance are available now, and developers can access the codebase on GitHub. Learn more at careerhighways.com.
About Career Highways Career Highways is a workforce strategy and technology company that helps large, complex organizations design and activate transparent, skills-based career pathways at enterprise scale. Its services and tools — including Skills Intelligence — digitize job architecture, map skills to roles, and turn workforce data into clear pathways for mobility, upskilling, and planning. By pairing AI-enabled insight with human expertise, the company supports better decisions about talent development, internal movement, and the changing impact of technology on work.
Media Contact: Philip Robertson, Impact Partners PR LLC
For thirty years, durable software was the only path to the outcomes organizations wanted — so we built it, maintained it, migrated it, and kept feeding it. Most enterprises now spend 60–80% of their IT budgets just sustaining systems that already exist, leaving twenty cents on the dollar for anything new. The machine developed an appetite — and a whole services ecosystem to keep it fed.
AI is being sold as a way to build software faster. That’s true, and it’s the least interesting part. The real shift: when AI can assemble software on demand to serve a specific outcome and dissolve it when the moment passes, software stops needing to be durable. It becomes temporal — built for the moment, gone when the moment ends. The question that’s haunted every technology budget for thirty years finally has an answer: it stops when the moment passes.
But temporal software needs a venue — a durable, governed foundation of organizational knowledge, ontology, and intelligent infrastructure that every temporary application inherits. Most organizations are deploying AI without one. They’re booking events without a venue. The engineers who matter most in this model aren’t building applications — they’re building the venue. We call them intent engineers.
Most people treat AI like a vending machine — feed it a question, take the answer, walk away. Liz Eversoll built hers to run the company. This is a layer-by-layer tour of a working operating system built on Claude, and why the part no one can copy isn’t the model — it’s the governed core of canon and rules underneath it.
The old investing adage is to make money while you sleep. I want more than that. I want the company to run while I sleep — to our standards, our context, our policies — whether the work in front of it is done by a person, a person with AI, or automated outright.
Most people treat AI like a vending machine: feed it a question, take the answer, walk away. I built mine to run the company.
Over the past month I have assembled what I can only describe as an operating system: a layered stack, built on Claude, that does the work a company generates so I can spend my time on the work only a CEO can do. It has the same shape as the operating system on the device you are reading this on — and that shape is the point. I will walk it layer by layer and show how each one is built.
What an operating system is for
An operating system earns its keep by doing two things at once. It abstracts the machine, so you work at a high level instead of flipping bits. And it governs access, so the things that must be reliable stay reliable no matter what runs on top.
Hold onto that word: governance. Almost everything that separates my system from a clever assistant — or a second brain — comes down to it: a privileged, trusted core that decides what is true and what is allowed, with everything else running above it. Strip the governance out and you do not have an operating system. You have a chatbot with good intentions.
Here is the full stack.
The engine
At the very bottom is the reasoning the whole system runs on — and after a real search, that is Claude. I did not start here. We worked through Copilot, then Perplexity, then ChatGPT, and settled on Claude. It is not that the others can’t do this, it is that Claude is the only one that could operate every layer of this stack — a connected through-line from the engine to the screen. It reaches our systems of record, runs the skills, executes the scheduled processes, and holds to our standards across all of it. The others answer questions. Claude runs the system.
Above the engine is the wiring — the connectors that let the system reach the tools the business already runs on, through MCP. I deliberately think of these by category, not brand: the CRM, the financial system, the HRIS, the email and messaging layer, any system of record. The goal is a true driver layer — that you can swap a tool underneath and everything above keeps calling the same operations while the wiring handles the translation. We are not quite there yet, but that is the direction.
These connectors have one property worth flagging now: some can write back, and some can only read. That single difference decides whether a whole process can finish inside the system or stalls at the screen you were trying to leave. I will come back to it.
The governed core
The next two layers are the ones almost everyone skips — or cannot implement — and they are the entire reason this works. They are also where our proprietary IP lives. Together they are the governed core: the trusted context the system runs on, and the rules that govern what it may do.
Start with canon. Every operating system has a file system — a structured, persistent record of what the machine knows. Ours is our company canon: our single source of truth. It is our trusted business context — definitions, strategy, standards, the design system, operating concepts — written down once and treated as authoritative. It is not a folder of notes, our Sharepoint or a Google Drive connected to the system. Our canon is consulted in a strict order of precedence, so the system always reaches for the most authoritative context available before anything lower down: true canon first, company data, and then other ranked sources.
Canon is the thing you actually run a company on, and it is what lets you automate a process with confidence. When a function needs a fact or a standard, it reads from canon. Other systems may not invent an answer outright, but without a governed source of truth you never know which version you will get — the whole junk drawer is on the table to choose from. Canon takes the junk drawer away.
Then the rules. A real operating system does not let every program do everything; it has a protected mode that gates privileged actions so one misbehaving program cannot corrupt the machine. Ours are governed by SIGN — a specification language we built to encode our policies, standards, data and boundaries in an explicit, machine-checkable form. The rules do not just sit in a document; SIGN’s guidelines let agents reason over our enterprise knowledge in a governed manner — so when the system acts, it is reasoning within the lines we have drawn, not improvising around them. Changing a policy or the ruleset in SIGN is itself governed — proposed, reviewed, and published to the system — so the boundaries stay authoritative instead of drifting.
A concrete one: a process can review a deal and recommend moving it forward, but it cannot advance a deal past Qualified to Buy on its own. That takes me. The intelligence on top can propose; it cannot cross the line the rulebook draws. Recommendation is cheap; authority is governed.
The toolkit
On top of the governed core sit the core functions — the system calls. I started here, with the mundane things I was spending an inordinate amount of time on: finding information, transforming it, storing it, sharing it. Find, transform, store, share, review — the small, reliable operations everything else is built from.
These are skills I built once and now invoke constantly, and the important thing about them is what they govern. One does not just write a document — it writes in our voice. One does not just make a deck — it makes one to our brand standard. One takes a messy contract and standardizes it to our format, clause by clause. These skills carry the voice and the standards into every output, so find happens in a precedented way and transform lands on brand every time, no matter who runs it.
Because each skill reads from canon and obeys the rulebook, the same skill produces the same quality for anyone in the company.
Standing operations
Above the toolkit is where the system stops waiting to be asked.
These are standing operations — processes I built once that now run on a schedule or a trigger, each chaining the toolkit’s functions into real work. The system does research and writes first drafts of articles. It reviews the week’s news and social and drafts the posts. It reviews my pipeline and flags what has stalled. It handles customer and prospect follow-up, prepping me before a meeting and capturing commitments after. Every Monday morning a dashboard assembles itself from live CRM and financial data and lands in my inbox before I am awake.
None of these is a prompt I retype. Each is a standing process — scheduled or triggered — that runs the toolkit’s functions on its own. And this is not only mine: everyone in the company builds their processes on the same toolkit, composing the same governed functions into the work their role needs. One shared foundation, many processes.
The round trip
This is the property I flagged earlier: a process only completes if the system can write back, not just read.
Pulling data out of a tool is easy. The test is whether you can push the result back in — close the loop — without a human re-keying it through a screen. When that round trip works, an entire workflow can run inside the system: read the data, do the work, write the result back to the system of record, automate the whole thing.
This is why I run my task list in Notion and draft in Superhuman. I read, transform, write back, and let the process run end to end. When the round trip is open, a tool becomes a place the system can operate, not just observe. I say more in a companion piece about what this means for the tools that don’t allow it — because it is a bigger deal than it first appears.
The cockpit
The top layer is the one I touch.
This is the screen — where I stop operating the machine and start operating the business. I ask how we are doing, and the system pulls the live picture: pipeline, cash, what is stalled, where risk is concentrating. I do not assemble the report. I read it, and then I do the part that is actually mine — decide, delegate, set direction. And when I need something built, I reach straight past the screen and call any function in the toolkit on demand.
Everything below this layer exists so that this layer is all I have to touch.
Why this works
Step back, and the value is not where most people look. The engine is Claude — extraordinary, and available to anyone. The connectors are standard. The screen I talk to is the easy part, and the standing processes are just the toolkit on a schedule. Strip all of that away and what is left — the part nobody can copy from us — is the governed core: our canon and our rules, written in SIGN and reached over MCP.
Canon, SIGN, and the wiring that lets them act: that is the differentiator. It is also why automation is trustworthy here and brittle elsewhere. A second brain, or an agent loose in a folder, has the engine and the apps and the screen; what it lacks is a governed core, so it drifts. Ours does not, because every layer above reads from trusted context and obeys encoded rules.
And because the core is governed rather than personal, this is not really my operating system. It is the company’s operating system. The same context, the same standards, the same rules are available to anyone — so the business runs the same way no matter who is at the keyboard, and whether the work is done by a person, a person with AI, or fully automated.
Which is the whole ambition. The old adage is to make money while you sleep. I want more than that — I want the company to run while I sleep, to our context and our standards and our policies, and then to hand me, in the morning, only the decisions that were ever really mine.
