Understanding AI.

A knowledge layer is the structured foundation that connects a general-purpose AI model to how your specific business actually works: its data, its processes, its language, and its rules. The model supplies raw intelligence; the knowledge layer supplies the context that makes that intelligence useful to you and no one else.

It is not a database, a document store, or a wrapper around vector search. Those are ingredients. A knowledge layer is the purpose-built infrastructure that decides what the AI can see, when it should act, which tools it can use, and what "correct" looks like inside your four walls.

This is the part most companies skip. They buy a model and expect magic. It is the top reason AI works in a demo and fails in production. Augustus is, at its core, a system for building this layer for you.

An agent is an AI system that takes actions to accomplish a goal, not just one that generates text. An LLM can draft an email. An agent can read the inbox, find the message that needs a reply, pull the customer's history from your CRM, draft the response, and send it, then log what it did.

The difference is agency. An agent plans, calls tools, checks the result, and adapts. It turns "AI that can talk about your work" into "AI that does your work."

Augustus builds agents that run real operations end to end, with every action previewable and reversible so a human stays in control of anything that matters.

MCP is an open standard for connecting AI models to the tools and data they need. Think of it as the USB-C port for AI. Instead of every model needing a custom integration for every app, MCP gives them one common way to plug in.

It matters because it makes AI portable. Tools you connect through MCP keep working as models improve, and you are not locked into a single vendor's ecosystem.

Augustus is MCP-native. It speaks the protocol out of the box, so it can reach your systems through the same standard the rest of the industry is converging on.

Think of it as a stack. The LLM is the brain: general reasoning and language. The agent is the worker: it uses the brain to take actions and get things done. The knowledge layer is the foundation: the context that tells the worker what your business is, what it wants, and what the rules are.

A brilliant brain with no context is a very smart stranger. It reasons beautifully and gets your specifics wrong.

The knowledge layer decides whether the rest of the stack actually works. Get it right and average models perform like specialists. Get it wrong and the best model on earth still hallucinates your policies.

A general-purpose model is a generalist: strong everywhere, expert nowhere. A specialized deployment is that same model wrapped in your context, your tools, and your guardrails so it performs like an expert on the specific work you care about.

On the tasks they are built for, well-specialized systems consistently beat raw general-purpose ones. They often match much larger, more expensive models at a fraction of the cost, because they are not wasting reasoning re-deriving what your business already knows.

Specialization is not about a bigger model. It is about a better foundation, and that foundation is what Augustus builds.

Augustus is an open protocol for running your business through AI. You point a coding agent at it. It audits one of your processes, builds an AI system for it, tests that system on your real data, and runs it. You approve what matters. It does the rest.

It is not a chatbot, and not another app to log into. It is the operating layer your business runs on, reached through the tools you already use.

A chatbot talks. Augustus does the work. It reads your business, builds a real system for a real process, connects to your live tools, and runs it, with a human approving anything that matters.

ChatGPT answers a question and forgets it. Augustus grounds itself in your business, keeps that context, and gets better with every system it runs.

No. You talk to Augustus in plain language through a coding agent. It explains each step and asks before it does anything. If you can describe how a task works, you can automate it.

Setting up the coding agent takes a few minutes. See Setting up your AI tool below.

No. An automation tool wires one app to another and stops. Augustus rebuilds your operations around AI. It audits how your business runs, designs the systems, and runs whole processes for you, end to end.

It does the work your team repeats, makes the calls it can make on its own, and loops you in for the ones that need you. You point it at your operations, not a single task.

Building and testing are free. Once a system is live, Augustus is a flat $199 a month per seat, where a seat is one person on your team it works for. That is the whole platform price, no matter how much your systems do: no usage metering, no per-task fees, no add-ons.

The heavy model runs on your own AI account, so you keep control of that spend and your data.

Yes. Every workspace is isolated at the database level. Credentials are encrypted. Augustus runs on your own AI key and trains on nothing. Every irreversible action waits for your approval.

The Security and Privacy section covers the details.

The full standard is public: the lifecycle, the tools, and the rules, in plain language and machine-readable schema. Anyone can read exactly how it works, drive it from any AI tool, or build a compatible engine.

Augustus is the hosted engine that runs the protocol. The standard is open; the engine is how you run it without building your own.

Three areas are reliably ready: internal knowledge work (answering questions across scattered docs, drafting, summarizing), document and data work (reading, extracting, routing, reconciling), and revenue operations (lead research and scoring, follow-up, CRM hygiene, renewals).

The pattern behind all three: work that has a clear input, a repeatable process, a way to check the output, and a human who can stay in the loop. That is where AI is dependable.

Where it struggles: open-ended creative judgment, high-stakes decisions with no clear criteria, and anything that requires accountability a machine cannot hold. Those stay human for now.

The biggest returns come from high-volume, repetitive, information-heavy work: the tasks that eat a team's hours without needing their judgment. Document processing, internal Q&A, and sales intelligence lead the pack because the volume is high and the right answer is checkable.

The compounding factor is the knowledge layer. Research consistently finds that the companies capturing real value from AI are the small minority that built this layer first. They are many times more likely to see measurable P&L impact than those who just bought a chatbot.

ROI follows repetition times checkability. Find your most repeated, most verifiable process and start there.

Businesses with fragmented information, custom processes, and ambitions that outpace their headcount. If your knowledge lives in ten tools and three people's heads, and you would grow faster if you could clone your best operator, you are the ideal case.

Smaller and mid-sized companies often gain the most. They carry the same operational complexity as large enterprises but not the staff to brute-force it, so each automated process is a larger share of capacity returned.

The common thread is not industry. It is repetition at volume. AI pays off most where a small team is doing work that does not require a human, at a volume that hurts.

Because they buy the brain and skip the foundation. Studies through 2025 found that the large majority of enterprise generative-AI pilots produced no measurable return, and only a small fraction of companies captured value at scale.

The cause is almost never the model. It is missing context. The AI does not know the business's data, processes, or rules, so it produces plausible answers that are wrong, and trust collapses.

The fix is unglamorous and decisive: build the knowledge layer, keep a human in the loop, and prove each system on real work before trusting it. That sequence is exactly how Augustus is designed to operate.

Almost certainly yes, and probably not for the reason you fear. The myth is that you have to "clean up your data first." You do not. A good knowledge layer is built to work with messy, scattered, real-world information. Waiting for perfect data is how projects die before they start.

What you actually need is three things: a specific painful process worth fixing, a team willing to be involved for a few hours, and a realistic timeline. That is it.

If you can name one process that eats hours and follows rules, you are ready to start.

Start where the work is repetitive, high-volume, and easy to check: internal knowledge retrieval, document and data handling, or a slice of sales or support operations. Early wins should be things you can verify at a glance.

Avoid starting with anything that needs deep creative judgment or makes high-stakes calls without clear criteria. Those are the hardest to trust and the fastest way to sour a team on AI.

Pick one narrow, painful, checkable process. Prove it. Then expand from a position of trust, which is how momentum compounds instead of stalling.

Most of the effort goes into the knowledge layer, teaching the system your context, not into the model, which is a commodity you can swap. A single well-scoped system can go from audit to live in days to weeks, not quarters.

Augustus runs a deliberate sequence: it audits a process, builds the system, tests it against real cases, and takes it live only with your sign-off. Every step is previewable, and nothing touches production without approval.

On price, Augustus is a flat $199 a month per seat. That is the whole platform price, no matter how much your systems do. The heavy model costs run on your own AI provider account, so you keep control of both the spend and the data.

Upload the file right in the chat. In your AI app, attach the spreadsheet, CSV, or export and say "load this into my data." Augustus reads it and saves the rows into your workspace so your systems and questions like "what's my pipeline?" work off your real data.

You do not point it at a file on your computer or a shared drive. The chat cannot reach into your disk. The upload is how the data gets in, and you only do it when the data changes.

Two kinds of things, two homes: a list or table of records (deals, contacts, a price list) becomes your data, and a document written in prose (an SOP, a brief, call notes) becomes company knowledge. You can upload both, and Augustus files each in the right place. If a file has both, it splits them for you.

An AI tool is an app that talks to AI and can do things on your computer. The Claude, ChatGPT, and Grok apps, plus editors like Cursor and Windsurf, are the common ones. There are free, open-source options too, like Cline, Continue, Goose, and Zed. All are free to start.

Augustus plugs into the tool, so the tool becomes the place you talk to Augustus. You never write code. You type in plain English, and it does the rest.

Setup takes about five minutes, and you only do it once.

It comes down to two paths. If you work in a chat app like Claude or ChatGPT, use Chat: you paste one link and you are connected. If you work in a coding agent like Claude Code, Cursor, or Codex, use Code: you paste one message and it installs itself.

Pick whichever you already use. Both are free to set up and take a few minutes, done once. If you are on a free Claude or ChatGPT plan (connectors need a paid plan), use Code.

Chat apps connect with one link and no sign-in. This works for the Claude app, the ChatGPT app, and any chat app that takes a custom connector.

1. On the Augustus home page, open the setup box, keep the Chat tab, and press copy. You get a connector link, a web address that ends in /w/ and your own key, so it connects with no sign-in.

2. In your chat app, open Settings, then Connectors. (ChatGPT: turn on Developer Mode first, under Connectors or Apps. Adding connectors needs a paid Claude or ChatGPT plan.)

3. Click "Add custom connector", paste the link, and click Add, then Connect.

4. Go back to the chat, type "hi", and press enter. Augustus takes it from there.

Coding agents install Augustus themselves from one message. This works for Claude Code, Cursor, Codex, VS Code, Windsurf, Cline, and any MCP agent.

1. On the Augustus home page, open the setup box, click the Code tab, and press "Copy message for your agent".

2. Open your coding agent and paste the message into its chat.

3. It reads the message and adds Augustus itself, using the address and key inside. Restart the agent if it asks, so the tools load.

4. Type "hi" and press enter. Augustus takes it from there.

Note: open-source agents (Cline, Continue, Goose, Zed, Qwen Code) also need their own AI key to think. See Running your systems below. The message contains the address (https://app.augustus.so/api/mcp) and your key, so you can also add Augustus by hand in any tool's MCP settings.

The Augustus home page has a copy button for both paths, Chat and Code. If something will not connect, email support@augustus.so and we will walk you through it, step by step.

There are two separate keys, and it helps to keep them straight. The free Augustus key connects your AI tool to Augustus. Your AI key is the account Augustus uses to actually think when a live system runs, and it stays yours.

Running on your own key means the heavy model costs are billed to you at cost, your data flows through the provider you already trust under your own terms, and Augustus trains on none of it. You keep control of both the bill and the data.

You only need this when you take a system live. Auditing, building, and testing are free and ask nothing of you.

You do not touch a dashboard. In your AI tool, tell Augustus you want to connect your AI key. It asks which provider you use and for the key itself, you paste it in, and it checks the key works before saving it, encrypted.

From then on, your live systems run on that account. You can change or remove the key any time by asking Augustus.

Augustus is model-agnostic. You can connect Anthropic, OpenAI, Google, or OpenRouter. Pick the one you already have, or the one whose models you prefer. You can switch later.

If you want one key that reaches almost every model, including open-source ones, use OpenRouter. Steps are below.

1. Open your web browser and go to console.anthropic.com. Sign in, or create an account.

2. Under Billing, add a payment method. The models are pay-as-you-go, so you pay only for what you use.

3. Open "API keys", click "Create key", and copy it. It starts with sk-ant-.

4. In your AI tool, tell Augustus you want to connect an Anthropic key, and paste it in.

1. Open your web browser and go to platform.openai.com. Sign in, or create an account.

2. Under Billing, add a payment method. The models are pay-as-you-go.

3. Open "API keys", click "Create new secret key", and copy it. It starts with sk-.

4. In your AI tool, tell Augustus you want to connect an OpenAI key, and paste it in.

OpenRouter is a single account that reaches models from Anthropic, OpenAI, Google, and the open-source world through one key. It is the simplest way to try different models without opening an account with each provider.

1. Open your web browser and go to openrouter.ai. Sign in, or create an account.

2. Click "Add credits" and add a small amount to start. You pay only for what you use.

3. Go to openrouter.ai/keys, click "Create key", and copy it. It starts with sk-or-.

4. In your AI tool, tell Augustus you want to connect an OpenRouter key, and paste it in. You can name the model you want, or let Augustus pick a sensible default.

Yes. Open-weight models like Llama (Meta), Qwen (Alibaba), DeepSeek, GLM (Zhipu), and Kimi (Moonshot) all run through OpenRouter, so connect an OpenRouter key and ask Augustus to use the open model you want. Same key, your spend.

One distinction worth making: those are models, not agents. There is no separate "Llama agent" to install. You run Llama or any open model either as the brain behind your AI tool (Cline, Continue, Goose, Zed, and Qwen Code are all model-agnostic) or as the model Augustus uses for live runs. The same key works for both.

If you host your own model behind an OpenAI-compatible endpoint, Augustus can point at that too. Just give it the address and key.

RAG is a technique where, before the model answers, the system retrieves the most relevant documents from your data and hands them to the model as context. Instead of answering from memory, the model answers from your source material.

It works. Grounding answers in retrieved facts cuts hallucination and lets the AI show its source.

But RAG alone is not a knowledge layer. Retrieval tells the model what to read. It does not tell it how your business operates, when to act, or which tools to use. RAG is a necessary component of the foundation, not the whole thing.

Fine-tuning means further training a model on your own examples to shift its behavior. It has real uses, but for most businesses it is an expensive distraction dressed up as sophistication.

The catch: a fine-tuned model is frozen in time. When a better base model ships, which now happens every few months, your investment is stranded and you fine-tune again. A knowledge layer adapts to new models the day they arrive. You upgrade the brain without rebuilding the foundation.

For the vast majority of use cases, a strong model plus a well-built context layer beats a fine-tuned model, costs less, and ages far better.

Because the failure mode of enterprise AI is not stupidity. It is confident wrongness. A majority of enterprises name hallucination and unreliable output as the main barrier to scaling AI, and that unreliability is a context problem, not an intelligence problem.

The discipline of getting the right information to the model at the right moment has a name: context engineering. It is becoming the real edge in applied AI. Same models, wildly different results, decided by the foundation underneath.

This is the thing Augustus is built around: not a smarter model, but a better-fed one.

Two commitments define it. First, Augustus does not train any model on your business's information. Your data is used to do your work, never to improve a model other companies will use.

Second, and unusually: Augustus runs on your own AI provider account. The model calls that process your data are made through, and billed to, your key, so your sensitive information flows to the provider you already trust, under your own agreement and retention settings, not into a vendor's black box.

On top of that, every workspace is isolated, credentials are encrypted, and any action that changes a real system is previewable and gated. You can adopt AI without handing your data to one more third party.

On consumer ChatGPT (Free and Plus), the default is that your conversations can be used to improve their models unless you turn it off, and those controls have shifted over time. The business and enterprise tiers are different, with training off by default.

The practical takeaway: what is safe on a personal account and what is safe for company data are not the same thing, and the defaults are not built around your confidentiality.

In 2025 Anthropic changed its consumer terms: consumer chats can train models by default, with longer retention, unless you opt out. Commercial products like Claude for Work are carved out and are not used for training by default.

Same lesson as OpenAI: the consumer defaults optimize for the vendor's model, not your privacy, so where your business data lands, and under which terms, is a decision you should make deliberately.

Pasting company data into a consumer chatbot means accepting that vendor's defaults, retention, and training policy, which change without your input. It is convenient, and it is the wrong place for anything sensitive.

Augustus inverts the arrangement. It orchestrates the work but sends your data through your own provider account under your own terms, trains on nothing, isolates every workspace, and gates every consequential action. You get frontier models without giving up custody of your data.

Convenience should not cost you control. The right setup gives you both.