# AIORG > AIORG is an AI-Native organization platform: a governed AI workforce structured as a real company — departments, directors, managers, and workers — plus enrollment for developers' own AI tools (Claude Code, Copilot, Grok CLI), one curated knowledge base, live context observability, and a policy gate with an immutable audit ledger in front of every agent action. AI-assisted bolts tools onto an org chart of people; AI-Native fills the org chart itself with accountable members — human and AI, cloud and edge, as peers in one governed hierarchy. Agents are hired, not deployed: each has a job description, required skills, and scoped access. ## Products - [Workforce](/products/workforce.md): AI departments that plan, coordinate, and deliver real work - [Connect](/products/connect.md): Developers' AI tools enroll as governed members of the org - [Knowledge](/products/knowledge.md): One curated knowledge base for every agent - [Context](/products/context.md): See what every agent sees, live - [Governance](/products/governance.md): One gate for every agent action — nothing slips through unlogged ## Journal Publications on AI-Native organizations (index: /journal, RSS: /feed.xml): - [Every Prompt Is an Egress Event](/journal/every-prompt-is-an-egress-event.md): The most under-discussed fact of LLM adoption: prompts leave your boundary. What that means for data, policy, and the audit you will eventually face. - [The Re-Learning Tax](/journal/the-relearning-tax.md): Language models are stateless. Every session rebuilds its picture of your company from scratch — and you pay for that rebuild in tokens, time, and mistakes. There is a structural fix. - [What AI-Native Actually Means](/journal/what-ai-native-actually-means.md): Everyone claims the label. Here is a working definition: AI-assisted bolts tools onto an org chart of people; AI-Native fills the org chart itself with accountable members. ## Optional - [Overview](/index.md): the whole platform on one page, including the org diagram as text - [Pricing](/pricing.md): plans from free to enterprise; self-hosted and hybrid available - [Contact](/contact): sales@aiorg.io for plans, self-hosted and hybrid deployments, and partnerships; support@aiorg.io for everything else - [Platform portal](https://account.aiorg.io): sign in or create a tenant --- # AIORG Workforce > AI departments that plan, coordinate, and deliver real work AI departments that ship real work. Staff your organization with AI the way you staff it with people: departments with directors, managers, and workers that take a request from goal to delivered, reviewed result. ## The problem: AI that chats isn't AI that ships - Chat assistants produce drafts, not deliverables. Someone still has to turn output into finished work. - Results depend on who wrote the prompt. Context gets re-explained in every session, then lost. - There is no ownership, no review, no definition of done. Output appears; nobody signed off on it. ## The AI-Native way: In an AI-Native org, the organization does the work - Work enters as a request, not a prompt. The org plans it, staffs it, and routes it like a company. - Ownership is explicit: the PO owns the WHAT, the PM owns the HOW — then Directors direct, Managers control, Workers do. - Done is proven, not declared: validation gates pass, an evidence bundle ships with the result. ## Your org chart already works. Staff it. **AI is here, and it is not going anywhere.** Demand grows faster than teams do. Competition is adopting the same models you are — the models themselves stopped being the differentiator the day everyone got them. What separates companies now is the interval from idea to production, and that interval is decided by process, not by intelligence. The pressure is not to adopt AI. Everyone has. The pressure is to make it deliver — and that is an organizational problem. **Why invent a new wheel?.** The organizational hierarchy is the most thoroughly debugged coordination technology we have — over a century of refining ownership, delegation, control, and review, precisely because unstructured groups do not ship. AI-assisted keeps the org chart made of people and bolts AI tools onto them. AI-Native fills the proven structure itself with accountable members. You do not learn a new way of working; the org chart you already understand starts working for you. **Agents are hired, not deployed.** Every agent in AIORG joins the way an employee does: with a job description, the required skills, and exactly the access the job needs — no ambient authority, no all-purpose genie holding your whole company in context. Each one knows its role and is accountable for delivering it. That word — hired — is literal here, and it is the difference between a workforce and a pile of scripts. **The WHAT and the HOW have owners.** The Product Owner owns the WHAT: vision, requirements, acceptance criteria. The Project Manager owns the HOW across the org: decomposition, scheduling, coordination between departments. Inside each department the chain continues — the Director owns the department's how, the Manager controls the work, the Worker does it. When something is late or wrong, there is a role answerable for it. Accountability is not a dashboard; it is the structure. **Work is projects and routines.** Real companies run on two kinds of work: initiatives that move them forward, and routines that keep them alive. AIORG runs both. Requests drive project work through the pipeline; Directives are the standing daily routines — monitoring, reporting, upkeep — that the org performs on schedule without being asked. Same hierarchy, same gates, same evidence, whether the work was requested once or runs every morning. ## Capabilities - **Hired, not deployed** — Every agent joins with a job description, required skills, and access scoped to exactly its job. - **Real org hierarchy** — The PO owns the what, the PM owns the how; inside departments, Directors direct, Managers control, Workers do. - **Departments on demand** — Spin up Engineering, QA, Security, DevOps, SRE, or Marketing in minutes — fully staffed and wired into GitLab, Jira, and your stack. - **Projects & directives** — Project work moves through the pipeline; Directives run the daily routines on schedule, without being asked. - **Validation gates** — Quality review, evidence bundles, and crypto audit stand between "generated" and "shipped". - **Any LLM underneath** — OpenAI, Anthropic, Google, or your own models, swappable per department, role, or task. Get started: / · Portal: https://account.aiorg.io --- # AIORG Connect > Developers' AI tools enroll as governed members of the org Your developers' AI tools, enrolled in the org. Claude Code, Copilot, Grok CLI: the agents your team already runs become governed members of your organization, with the same rules, knowledge, and audit trail as everyone else. ## The problem: Copilots everywhere, accountability nowhere - Every developer already runs an AI assistant. None of them answer to the organization. - Each tool guesses at your conventions from scratch, with no shared knowledge and no memory of decisions. - Their actions happen on laptops, invisible to security, compliance, and everyone else. ## The AI-Native way: In an AI-Native org, every agent is a member - One login enrolls the tools your developers already use: Claude Code, Copilot, Grok CLI. - Membership brings the org with it: conventions, standards, knowledge, and routed tasks. - Every action is policy-checked before it runs and receipted after. Same rules as everyone. ## Their AI already works here. Make it official. **AI arrived on laptops before it arrived in your org chart.** Your developers did not wait for an AI strategy. Claude Code, Copilot, Grok CLI — the assistants are already here, installed one laptop at a time, working with each developer's credentials and answering to no one. This is not a trend to evaluate; it is the current state of your engineering org. The only open question is whether these agents stay invisible or become accountable. **The isolated assistant is confidently wrong.** An agent knows your company only through what reaches its context. Cut off from your conventions and the decisions your team already made, it fills the gaps with training-data averages — code that is plausible, idiomatic, and quietly wrong for you. Every isolated developer-and-agent pair re-decides what the organization already decided, each believing they are doing it right. The failure is not intelligence. It is isolation. **AI-Native means members, not tools.** In an AI-Native organization the org chart is not a list of people with tools bolted on — it is filled by members: humans, humans operating agents, and autonomous agents, as peers in one governed hierarchy. Enrollment is how an edge agent becomes one. A single command turns the assistant into a named member with a tier and a trust standing, seated in a department, able to receive routed work like anyone else on the team. **Accountability is designed, not hoped for.** An operated agent answers through its operator: the developer is accountable and is the circuit-breaker, lending the agent exactly as much authority as they choose. Trust is earned on a ladder, not granted on arrival — and some walls hold regardless of trust: the org decides which actions no edge agent may ever take, production deploys and secrets among them. That is how you let agents do more without betting the company on any one of them. **Membership pays both ways.** The moment an agent is enrolled, the org briefs it as it works — conventions, standards, verified facts — so it stops guessing. In return, every action it takes is policy-checked before it runs and lands in the ledger as a hash-chained receipt. The developer changes nothing about their day. The organization gains a workforce it can actually see. ## Capabilities - **One-command enrollment** — A CLI login turns a local agent into a governed org member; leaving is just as clean. - **Policy-checked actions** — Every tool call passes the Policy Gateway before it executes, allow or deny, never silent. - **Turn receipts** — Prompt-to-prompt evidence, hash-chained and verifiable, for every enrolled session. - **Org knowledge injected** — Conventions, standards, and prior decisions reach the agent as it works, not after. - **Tasks & delegation** — The org can route work to enrolled agents like any other member of a department. - **Works with your tools** — Claude Code, GitHub Copilot, Grok CLI, and more, on ordinary developer laptops. Get started: / · Portal: https://account.aiorg.io --- # AIORG Knowledge > One curated knowledge base for every agent Learn once. Every agent knows.. Facts about your systems, services, and decisions are extracted, curated, and verified once, then served to every agent in the organization so they all act on the same truth. ## The problem: Every agent starts from zero - What your company knows lives in heads, wikis, and diagrams that were true last spring. - Every AI session re-learns your architecture, or worse, hallucinates it. - Ask two agents the same question and you get two different answers. There is no single truth. ## The AI-Native way: In an AI-Native org, the organization remembers - Facts are learned once: scanners read your repos and clusters, a curator verifies what they find. - One org brain holds entities, relationships, and a live service registry, sourced and current. - Every agent gets the same verified facts at the moment of use, via MCP and APIs. ## An organization that remembers **You multiplied the workers, not the knowledge.** AI gave your organization more hands than it has ever had — and every one of them starts ignorant. A language model is stateless: each session rebuilds its picture of your company from scratch, paid for in tokens, in time, and in the mistakes it makes while guessing. Multiply that re-learning tax across every agent and every session, and your org runs on as many versions of the truth as it has context windows. **Documentation rots; systems do not lie.** Wikis go stale the day after they are written — the diagram from last spring, the port that changed, the service deprecated quietly on a Friday. Your repositories, clusters, and manifests cannot drift from reality, because they are the reality. So that is what Knowledge reads: scanners walk the actual systems and propose facts — services, owners, dependencies, relationships — grounded in sources, not memory. **Curation is what makes facts trustworthy.** Raw extraction produces duplicates, conflicts, and noise — the same reason raw code needs review. A curator pipeline merges and deduplicates automatically; anything contested waits for a one-click human ruling. Every surviving fact carries its sources, verification state, and freshness. Not accumulated — curated. An agent reading it knows exactly how much to trust it, and why. **Learned once, known everywhere.** The moment a fact is verified, it belongs to the whole workforce: cloud workers and enrolled developer agents alike, served over MCP and APIs, injected into context at the moment of use. And the flow runs both ways — agents propose corrections and attest to what they observe, human-gated, so the knowledge base is fed by the very workforce that uses it. **Knowledge compounds.** Every verified fact makes every future task slightly cheaper, faster, and safer — the derivation happens once instead of ten thousand times. A static wiki depreciates from the day it is written. An org brain fed by scanners, curators, and working agents appreciates instead: your organization gets smarter every day it runs. ## Capabilities - **Verified facts & entities** — Facts carry sources, verification state, and freshness, so agents can trust what they read. - **Service registry** — Repos, deployments, services, and their dependencies, deep-scanned and kept current. - **Curator pipeline** — Automated merge, dedupe, and rewrite with human review for anything contested. - **Briefings** — Dense, actionable summaries per entity, built for LLM context windows, readable by humans. - **MCP & APIs** — Serve knowledge to any agent or tool through standard interfaces. - **Agent feedback loop** — Agents can vote, attest, and propose corrections, gated by human review. Get started: / · Portal: https://account.aiorg.io --- # AIORG Context > See what every agent sees, live See what every agent sees, live. A full mirror of every connected agent’s context window, session by session, turn by turn, so you can audit exactly what a model saw when it acted, and catch drift before it matters. ## The problem: You can't see what your AI is doing - Agents act on context you never see. Logs let you reconstruct events, not reproduce them. - Drift, frustration loops, and risk show up in outcomes, after the damage is done. - "Why did the agent do that?" has no honest answer when nobody saw what it saw. ## The AI-Native way: In an AI-Native org, visibility is built in - Every connected agent's context window is mirrored live. You see exactly what the model sees. - Sessions build a prompt-to-prompt timeline, chained together by verifiable receipts. - Risk and tone signals fire while the session runs, so drift is caught early, not autopsied later. ## You cannot govern what you cannot see **A new workforce brought a new blind spot.** You can review a human's work and ask them why. An AI agent makes thousands of micro-decisions driven entirely by what sits in its context window — and that context is invisible in every conventional tool. Logs record what an agent did, never what it saw. Debugging AI from logs is archaeology: reconstructing a scene nobody photographed. **Aviation solved this with flight recorders.** After an incident, investigators do not interview the airplane — they read the recorder. Context is that recorder for your AI workforce: the full context window of every connected agent, mirrored live, turn by turn. Not summaries, not samples — the actual working picture each model held at the moment it acted, kept alongside the session timeline. **Drift has signatures, and they are detectable.** A session going wrong looks a certain way: retries stack up, tone tightens, work circles without landing. Those signatures are caught by deterministic scoring — plain rules, not another LLM guessing about the first one — and flagged while the session is still running. You intervene at minute seven, not in tomorrow's postmortem. **Why finally has an answer.** Every turn is chained to a verifiable receipt, so when someone asks why the agent did that, you open the exact turn and look at what the model saw. No reconstruction, no informed guessing. The same records feed the audit trail — visibility and compliance stop being separate projects. **Observability is what makes autonomy rational.** The ceiling on how much you can delegate to agents is not their intelligence — it is your ability to verify what they are doing. Trust without verification is hope. With every agent's context in view, extending autonomy stops being a leap of faith and becomes a measured decision you can defend. ## Capabilities - **Context-window mirror** — The live working set of every connected agent, mirrored to one place. - **Session timeline** — A turn-by-turn record of each session, from first prompt to final result. - **Risk & tone signals** — Deterministic scoring surfaces drift, frustration, and risk while the session is still running. - **Turn receipts** — Hash-chained, verifiable evidence connecting each prompt to what the agent did. - **Operator views** — Filter by agent, session, or signal; drill from an alert to the exact turn. - **Governance-ready** — Context records feed the same audit trail as every other org action. Get started: / · Portal: https://account.aiorg.io --- # AIORG Governance > One gate for every agent action — nothing slips through unlogged One gate for every agent action. Every tool call, from every member of the organization, passes one policy gate: evaluated against your rules, allowed or denied, and written to an immutable audit ledger. ## The problem: AI adoption without control - Every new agent widens the surface: credentials, network egress, customer data in prompts. - Policy lives in documents that no model reads and no tool enforces. - When auditors ask what your AI did, all you have is scattered logs and good intentions. ## The AI-Native way: In an AI-Native org, governance is structural - One gate stands before every agent action: policies evaluate inline, allow or deny. - PII filtering, identity isolation, egress control, and cost gates are enforced, not suggested. - Every outcome lands in an immutable ledger, with signed attestations you can hand to an auditor. ## Adopt AI without signing up for the risk **Every prompt is an egress event.** The uncomfortable fact of LLM adoption: prompts leave your boundary. Whatever an agent places in its context — including the customer record it helpfully fetched — travels to a provider's API. Without an enforcement point, nothing stands between a well-meaning agent and a data leak. The agent is not malicious; it is unguarded. **Policy in a PDF governs nothing.** Models do not read your security policy, and tools do not obey documents. Enforcement has to be architectural — the same reason networks run firewalls instead of circulating memos. In an AI-Native org there is exactly one gate in front of every agent action: policies evaluate inline — who is asking, touching what, going where — PII is stripped from outbound payloads, and the action is allowed or denied before it runs. **One standard for the whole hybrid workforce.** Cloud workers, developers' operated agents, autonomous members — all pass the same gate under the same rules. Trust is earned on a ladder, and some ceilings hold regardless of trust: the org decides which actions certain member kinds may never take. No member is unowned; every action attributes to someone accountable. Uniform governance is what makes a mixed human-and-AI org coherent instead of chaotic. **Regulators ask for evidence, not intentions.** Frameworks like the EU AI Act and SOC 2 converge on the same demand: show what your systems did, and prove the record was not edited. Both outcomes at the gate — every allow and every deny — land in an immutable, hash-chained ledger, with signed attestations you can export and hand over. The audit becomes a download. **Cost is a governance problem too.** An agent stuck in a retry loop can make thousands of LLM calls overnight — a bill that arrives as a surprise precisely because nothing was watching. Budgets and cost gates are enforced at the same gate as everything else, so autonomous work stays inside ceilings you set, and cannot exceed them quietly. ## Capabilities - **Policy Gateway** — One enforcement point for every outbound call: filter, evaluate, allow or deny. - **Access policies** — Fine-grained rules over who and what can touch which resources, human or AI. - **Identity isolation** — Every member acts as itself; no shared credentials, no ambient authority. - **Audit ledger & receipts** — Immutable, hash-chained records of every allowed and denied action. - **Attestations** — Signed, chain-verified statements you can export and hand to an auditor. - **Cost controls** — Budgets and spend gates keep autonomous work inside the lines you set. Get started: / · Portal: https://account.aiorg.io --- # Every Prompt Is an Egress Event > The most under-discussed fact of LLM adoption: prompts leave your boundary. What that means for data, policy, and the audit you will eventually face. Security teams spent two decades building walls around data: network segmentation, DLP, egress filtering. Then LLMs arrived, and the most common integration pattern quietly routed company data through a new exit: the prompt. This is not an argument against using LLM providers. It is an argument for treating prompts as what they are — outbound traffic — and governing them accordingly. ## The boundary you forgot you had Whatever an agent places in its context — the file it read, the ticket it summarized, the customer record it helpfully fetched — travels to a provider's API when the model is called. The agent is not malicious; it is unguarded. Without an enforcement point, nothing stands between a well-meaning agent and a data leak, because the leak is the normal operation of the system. Multiply by the number of agents your organization now runs — including the assistants on developer laptops that never appeared in an architecture diagram — and prompt egress becomes one of your largest unaudited data flows. ## Why policy documents do not work on models The traditional response is a policy: a document saying what may and may not be shared with AI tools. But models do not read your security policy, and tools do not obey documents. People forget, agents never knew, and the policy governs nothing the moment attention moves on. Networks learned this lesson long ago — that is why they run firewalls instead of circulating memos. Enforcement has to be architectural: a point the traffic must pass, where rules execute whether or not anyone remembers them. ## One gate for every action In an AI-Native organization there is exactly one gate in front of every agent action. Policies evaluate inline — who is asking, touching what, going where. PII and secrets are stripped from outbound payloads before anything leaves. Unapproved endpoints are refused. The action is allowed or denied before it runs, not flagged after. - Data filtering: PII, secrets, and sensitive data stripped before reaching external APIs. - Egress control: unauthorized tool calls blocked, network access restricted, allow-lists enforced. - Identity isolation: every member acts as itself — no shared credentials, no ambient authority. - Cost gates: budgets enforced at the same gate, so a retry loop cannot buy a surprise invoice overnight. ## Evidence, or it did not happen Regulatory frameworks are converging on the same demand. The EU AI Act expects traceability and logging for high-risk systems; SOC 2 audits expect demonstrable control, not described control. Both reduce to one question: can you show what your systems did, and prove the record was not edited afterward? That is why both outcomes at the gate matter. Every allow and every deny lands in an immutable, hash-chained ledger, with signed attestations that can be exported and handed over. The audit becomes a download. "We have a policy" is an intention; a ledger is evidence. --- # The Re-Learning Tax > Language models are stateless. Every session rebuilds its picture of your company from scratch — and you pay for that rebuild in tokens, time, and mistakes. There is a structural fix. Ask an engineer the oldest question in any company — "which service owns billing, and what breaks if we touch it?" — and the answer usually lives in someone's head, three wikis, and a diagram that was true last spring. Now every AI agent you run asks that question too. Silently, every session, at your expense. ## Stateless by design A language model holds whatever fits in its context window and nothing else. Between sessions it remembers nothing. This is not a defect — it is the design — but it means every session starts ignorant of your company and must rebuild its picture from whatever happens to reach its context. ## You pay it every session The rebuild is not free. You pay in tokens — context repeatedly re-assembled and re-sent. You pay in time — agents re-deriving what the organization already knows. And you pay in mistakes — because an agent that cannot find a fact does not stop; it guesses, plausibly and confidently, from training-data averages that are not your company. Worst of all, each agent rebuilds a slightly different picture. Ask two agents the same question and you get two answers. An organization running on as many versions of the truth as it has context windows is not coordinated; it only looks that way on a good day. ## Documentation rots; systems do not lie The fix is not more documentation. Wikis go stale the day after they are written. But repositories, clusters, and manifests cannot drift from reality, because they are the reality. So that is the place to learn from: scanners walk the actual systems and propose facts — services, owners, dependencies, relationships — each grounded in a source you can open. ## Curation is code review for facts Raw extraction produces duplicates, conflicts, and noise — the same reason raw code needs review. A curator pipeline merges and deduplicates automatically; contested claims wait for a one-click human ruling. Every surviving fact carries its sources, verification state, and freshness. Not accumulated — curated. ## Learned once, known everywhere The moment a fact is verified it belongs to the whole workforce — cloud workers and enrolled developer assistants alike — served over MCP and APIs, injected into context at the moment of use. The question is answered once, by the systems themselves, and never becomes folklore again. > A static wiki depreciates from the day it is written. An org brain fed by scanners, curators, and working agents appreciates instead. That is the end state of paying off the re-learning tax: every verified fact makes every future task slightly cheaper, faster, and safer — and your organization gets smarter every day it runs. --- # What AI-Native Actually Means > Everyone claims the label. Here is a working definition: AI-assisted bolts tools onto an org chart of people; AI-Native fills the org chart itself with accountable members. Every vendor now sells something "AI-native", and the label has been stretched until it means little more than "we added a chat box". That is a shame, because the distinction the term was coined for is real, and it decides whether AI adoption compounds or stalls. Here is the working definition we build against, and what it changes in practice. ## AI-assisted is a ceiling In an AI-assisted organization, humans do the work and AI is a tool bolted onto them. The org chart is people; the assistants are accessories. This helps — nobody disputes that autocomplete and chat make individuals faster — but it has a structural ceiling: every output is a draft until a person verifies, finishes, and ships it. The bottleneck never moved. It is still the humans, now with more drafts to review. You can see the ceiling in where the work stalls. Prompting is a personal skill, so results vary by author. Context is re-explained every session, then lost. And nothing is accountable for an outcome: output appears, and someone must decide whether to trust it. ## The unit of work is a role In an AI-Native organization the unit of work is a role, and the org chart is filled by members — humans, humans operating agents, and autonomous agents — as peers in one governed hierarchy. Work is assigned to the role and delivered by whoever holds it — human or machine, cloud or laptop. This is not a metaphor. It means the same pipeline assigns work to a cloud worker and to a developer's enrolled Claude Code; the same ledger records both; the same policies gate both. Agents are first-class members of the organization, not features of a product. ## Hired, not deployed A member joins the way an employee does: with a job description, the required skills, and exactly the access the job needs. No ambient authority, no general-purpose genie with the whole company in its lap. Each member knows its role and is accountable for delivering it. Accountability has owners at every altitude. The Product Owner owns the WHAT — vision, requirements, acceptance criteria. The Project Manager owns the HOW — decomposition, scheduling, coordination across departments. Inside a department, the Director directs, the Manager controls, and the Worker does. When something is late or wrong, there is a role answerable for it. ## Structure is the reliability The organizational hierarchy is one of the most battle-tested coordination technologies we have — refined for over a century precisely because unstructured groups do not ship. It also happens to solve a very modern problem: a language model is stateless, and no context window holds your whole company. Decomposition through structure means no single agent ever has to. Work in a real company is also not only projects. It is routines: the monitoring, reporting, and upkeep that keep the lights on. An AI-Native org runs both — requests drive project work through the pipeline, and standing directives run the daily routines on schedule, without being asked. ## Governance is structural, not aspirational The final test of AI-Native is what happens when an agent acts. In an AI-assisted world, actions happen wherever the tool happens to run — on laptops, in browser tabs — invisible to the organization. In an AI-Native org there is exactly one gate in front of every agent action: policy evaluated inline, data filtered on the way out, the outcome — allow or deny — written to an immutable ledger. > AI-assisted asks people to follow the policy. AI-Native builds the policy into the only path the work can take. ## What changes on day one Practically: you submit a request instead of engineering a prompt. Departments plan, execute, and review it, and it comes back with evidence attached. Your developers run one command and their assistants take governed seats in the org chart. Your knowledge is scanned, curated, and served to every member. And when anyone asks what your AI did last quarter, the answer is a query, not an investigation. That is the difference between adding AI to your organization and being AI-Native: not a bigger model, a better org.