Product · Brain
Agents fail — not because of the models.
They fail because of context and data. Yours are scattered across docs, dashboards, and people’s heads, with eighteen definitions of “active user.” Until the business is defined in one place, every agent guesses.
One brain for the whole company.
Agents that know your business.
The Brain is where your company’s context and data definitions live together as code, visible and always current. Every agent you run — Lynk’s or your own — draws on the same brain.
As code, in your Git repo
The brain is markdown and YAML in your own repository. Version-controlled, reviewable, portable. Your context stays yours, forever — no vendor lock-in.
Context and data, together
Tribal knowledge and data definitions live in one semantic graph. Agents get what things mean and where the numbers live — in the same retrieval.
Deterministic by design
Business terms are named once. Agents pick them by name, and a deterministic engine compiles the same SQL from the same terms — every time, on your warehouse.
Agents that act on the business, not on guesses
Here is one interaction, from both sides — a marketing agent today. Support, product, ops, and analytics agents take the same path.
A lifecycle marketer sets a goal, in plain language: “Pause any campaign running 30% over our cost per activated user this week.”
No SQL, no exports, no waiting on another team. The marketer states the intent; the guardrails already live in the brain — what “activated user” means, this quarter’s targets, and the spend-authority policy the agent must apply.
The agent doesn’t hand-write SQL. It retrieves, picks, and hands off.
It pulls the campaign entity package, the glossary term “activated user,” and the spend-authority policy; picks the cost_per_activated_user metric by name; and hands it to the deterministic SQL engine, which runs the exact query on the warehouse. Then it acts, applying the spend-authority policy it retrieved — every retrieval and query logged.
Every task takes the same governed path
Two ways in, one trunk through the brain. Each task is grounded in the graph, compiled from named terms, and run under access control.
Brain
No black box between your data and your agents
Connect your sources once. In the middle sits a set of files you can open, not a model you have to trust.
Your business, in files agents can read
Every file in the brain is human-readable: open any one and see exactly what your agents know. You don’t hand-write them — your coding agent builds them and keeps them current with the Lynk build plugin.
One package per business entity: user, order, campaign. The knowledge file holds the entity’s business context in prose; the schema file defines its features, metrics, and relationships. When an agent reasons about “users,” this is what it reads first — so start here when you model a new part of the business.
# entities/user/schema.yml
entity: user
features:
is_active: signed in within the last 30 days
metrics:
active_users_count: count of users where is_active
relationships:
orders: user has many ordersEvery business term, defined once — “active user” means one thing everywhere. Agents resolve ambiguous language here before touching data, so a term has exactly one definition to land on.
How agents behave in your company: what to clarify before answering, when to refuse, how to present results. Edit it like a policy doc — every agent picks up the change on its next task.
Reusable workflows like a support-ticket triage or a campaign post-mortem: written once, runnable by any agent. Add one whenever you catch yourself explaining the same procedure twice.
The rules of the business — fiscal calendars, PII handling, which metrics are board-official. Agents apply them automatically; humans read the same file to know exactly what the agents will do.
Company-wide context that doesn’t belong to any single entity: how the company makes money, what this quarter is about. Add to it whenever a task needed a human to explain “how things work here.”
Per-domain depth — how marketing defines attribution, what finance means by revenue. Scoped so each domain’s agents get their domain’s truth without drowning in everyone else’s.
Built to pass your platform team’s review
The questions an evaluation will raise — answered before you ask.
Git-native, no new tool to govern
The brain is a directory in your repo: branch it, review it, merge it like any code, with a CI check from Lynk validating every change. Your existing PR flow is the approval flow, enforced as strictly as your repo demands.
Deterministic SQL engine
Agents never write raw SQL against your warehouse. They pick named terms; the engine compiles the exact query and runs it on Snowflake, BigQuery, Redshift, Databricks, or ClickHouse. That determinism is what makes every query reproducible and every answer auditable.
Every definition exists once
Schema validations reject a second definition of any entity, metric, feature, or relationship at build time. When someone asks why a number is what it is, there is exactly one place to look — and the eighteen “active user” definitions become one.
Evaluations before production
Run your agents’ real tasks against a proposed context change before it merges — tests, but for meaning, alongside the CI validation. A change that breaks yesterday’s results is caught in review, not in production.
Governance between agents and data
Access control, PII protection, and per-domain scoping sit in the query path itself. An agent scoped to marketing cannot read finance data — regardless of what it’s asked, or which assistant it runs inside.
Open to every agent you run
MCP and APIs expose everything the brain knows to Lynk agents, the agents you build, and the assistants your team already uses. The files themselves stay in your repo, readable by anything; live results run through Lynk.