Build with us
Six tactical patterns that turn internal AI from a clever local experiment into shared, observable, self-improving infrastructure.
09:41:02 objective.received
"Which founder cohorts improved after office hours?"
09:41:03 schema.read models/cohorts.sql
09:41:03 tool.call readonly.query
09:41:04 retrieval.fuse sql + graph + semantic
09:41:05 evidence.rerank 12 → 5 passages
09:41:06 response.complete grounded
Agent capability grows when you give models better primitives, not more predetermined paths.
The practical challenge is not making an agent perform one impressive task. It is building an environment where agents can discover context, choose reliable tools, preserve successful workflows, learn from traces, and serve an entire organization without becoming an ungovernable pile of prompts.
Two low-level tools cover a surprising amount of analytical work: inspect the current schema, then query the data directly.
A common instinct is to pre-build a narrow function for every question the business might ask. That creates a queue: every new analysis needs engineering to invent another endpoint. A capable agent can instead inspect model definitions, understand relationships, and construct the query required for the question in front of it.
Direct does not mean unrestricted. The database role should be incapable of mutation, limited to approved schemas or replicas, protected by statement and row limits, and fully logged. The model gets broad analytical flexibility inside a hard deterministic boundary.
-- active model definition
MODEL cohort_outcomes {
primary_key: cohort_id
dimensions: [program, batch, region]
measures: [revenue_delta, retention_90d]
joins: {
office_hours: cohort_id -> cohort_id
interactions: founder_id -> founder_id
}
}The agent sees the same active definitions the application uses, reducing invented joins and stale assumptions.
Keep operational writes physically or logically out of reach.
Do not rely on a prompt to prohibit mutation.
Limit rows, runtime, concurrency, and export size.
Store identity, purpose, SQL, result size, and latency.
The operational schema protects integrity. The agent-facing schema should reduce the number of joins required to understand an entity or event.
Reciprocal Rank Fusion combines ranked lists without requiring their raw scores to be comparable.
score(d) = Σ 1 / (k + ranki(d))Why did the robotics cohort improve after June?
Four signals active. Results are fused, reranked, and ready for citation.
A successful ad-hoc session should be able to graduate into a reusable organizational capability without becoming a copy-pasted prompt.
The operator and agent investigate a real problem together. The trace captures tools, context, corrections, decisions, and the final successful output.
agent run investigation_214 --traceDesign principleSkills are not chat transcripts with a filename. A durable skill separates objective, inputs, procedure, policy, exceptions, and evaluation.
As skills accumulate, routing quality becomes an engineering concern. Overlap creates indecision; gaps create improvisation.
reschedule_office_hourscalendar changes for group sessionsmove_founder_sessionmove an office-hours calendar eventanalyze_cohort_outcomescompare cohort performance by interventioncustomer_communication.*send, cancel, or revise a customer messageRun the resolver check to inspect overlap, coverage, names, and parameter boundaries.
One canonical skill handles the shared procedure with explicit variants.
Each route owns a distinct intent; together they cover the domain.
The planner can select a capability without semantic coin flips.
A nightly evaluator can turn traces and meeting artifacts into proposed improvements, while version control and human review keep production changes deliberate.
evaluation queue ready / 225 artifacts indexedLet evaluators produce patches, evidence, and tests. Require review before changing production prompts, tools, permissions, or records that trigger downstream action. The learning loop can move quickly without becoming self-authorizing.
Local harnesses are ideal for discovery. Shared runtimes are where context, skills, observability, and organizational learning compound.
A local CLI gives a technical operator maximum flexibility to discover useful workflows. The limitation is not capability; it is distribution.
Once the shared runtime has data and tools, a user can request the exact report or transient interface needed for a decision. Keep the generated artifact when it becomes recurring; discard it when it has served its purpose.
Submit the request to assemble a temporary interface.
Build one vertical slice through context, tools, skills, evaluation, and shared access. Avoid launching five disconnected experiments that cannot teach each other.
Choose a high-value analytical domain. Publish current schema definitions, create the constrained read role, and prepare an entity-level context table for retrieval.
The agent answers ten representative questions with executable SQL, cited evidence, and zero mutation capability.
Index the denormalized context through lexical, semantic, and relationship-aware retrieval. Fuse ranked lists, rerank the short list, and preserve source provenance.
Known-answer queries retrieve the required source in the top five, and every generated claim can point back to evidence.
Define the skill template, package the first proven workflows, register clear routes, and run overlap and coverage checks before merge.
A teammate can invoke the capability from a fresh session without knowing its tool sequence or original author.
Move validated capabilities into a shared harness, capture traces by default, and schedule an evaluator that proposes versioned improvements with regression tests.
A correction from one teammate produces a tested improvement proposal that can benefit every user after review.
Use these questions before expanding access or autonomy.
The strongest internal agent systems do not predict every workflow in advance. They create a controlled environment where models can inspect context, compose reliable tools, and preserve what works.
That is the shift from automation projects to organizational infrastructure: every successful investigation can become a skill, every correction can become an evaluation, and every teammate can inherit what the system learned yesterday.