The company that
thinks about itself.
AI CompMate is an organisational AI operating system, a thinking layer inside Microsoft Teams that reads how the business actually works, sets its own objectives, designs the plans to hit them, builds the agents that run them, and grades its own results. Autonomous in thinking, governed in acting.It is in active development for its first enterprise deployment; the numbers below are design targets. Today it delivers a governed morning brief in Microsoft Teams, the only chat platform supported; Slack, WhatsApp, email and Discord are roadmap.
Built on the engineering standards behind TAFI 279/279and Orions 55/55.
The CEO morning brief,
delivered as a message.
The thinking layer lives where work already happens. This is the intended shape of the daily brief and an assistant reply, rendered here as a design mock, not a live product screenshot.
One thing today: the client renewal is cooling, two timeline questions and a competitor mention in the last 48h. Suggested move: a 15-min exec check-in before Thursday.
- DECISION Sprint-5 scope locked, owner: R. Mehta
- RISK Sprint-5 requirements unclear, delivery at risk
- IGNORE 5 low-impact threads filtered out
Draft the check-in note to the client.
Drafted, grounded in the last 3 client calls and the open ticket. It needs your yes before anything leaves Teams.
Your company has
a thinking problem.
Every growing company has a leadership layer it can’t fully staff, the Chief of Staff, the COO, the analyst for every manager, the assistant for every employee. The roles that should exist, but can’t be afforded. That layer costs upward of $240K a year.
And it still misses things. The signals that matter, a slipping deal, a stalled decision, a blocked delivery, live in message threads and meeting transcripts, not the monthly reports humans read.
Roughly 50,000 words of signal pass through Teams every day. Almost all of it evaporates. AI CompMate is being built to read it, and then think about what to do.
Observe, propose, design,
execute, measure, adjust.
The part that makes it more than an assistant. The loop never stops, and once you lock a goal, it owns the follow-through.
9 passive intelligence streams
gaps & opportunities
objectives + evidence
a dependency graph of steps
ephemeral agent team
external writes wait for approval
impact vs forecast
re-checked every 14 days
Six capabilities most
“AI agents” don’t have.
The difference between a tool you prompt and a system that thinks: it decides what’s worth doing, does it, checks whether it worked, and improves, inside a governed frame.
It sets its own objectives
Gap and opportunity scans run against the live model of the business. Each objective is scored on impact × urgency × feasibility.
It designs its own blueprint
A planner turns a locked objective into a validated graph, dependencies, parallel branches, approval checkpoints, a cost estimate and a fallback.
It builds its own agents
Agents don’t exist until a task demands them. A factory writes the prompt, selects the tools, scopes the knowledge, then the agent runs and dissolves.
It checks itself against its metrics
Every objective and agent declares success criteria up front. Each run is measured against them and rolled into green / amber / red performance cards.
It learns and gets smarter
Winning assemblies are promoted into a pattern library; failures recorded as anti-patterns. The next similar task reuses the proven pattern, faster, cheaper, better.
It locks on and adjusts in real time
Once you approve a goal, a monitor tracks every step daily, nudging owners on day 2, escalating by day 5, re-checking relevance every 14 days. It stays on the goal.
It traces cause
and effect.
A live causal graph turns scattered symptoms into a root-cause chain. Not “delivery is red”, the chain of decisions that made it red, every edge confidence-scored.
See it think,
case by case.
Every scenario runs the same three beats, read the signal, reason to a conclusion, propose the action for your approval. Six on rotation; click any to hold.
A roadmap signal, not a delivered feature: quiet changes in how someone works.
Your best candidate is going quiet, and so is your shot at hiring them.
The account looks fine on the invoice. The meetings say otherwise.
Someone promised. Nobody followed up, until now.
The meeting ended. The minutes wrote themselves.
212 messages, 9 meetings. One thing actually matters today.
We fed it a 3-month chat. It caught a leaked password.
We handed the system a raw Teams chat history with no instruction beyond “make sense of this.” On its own it comprehended the intent, identified five domains, resolved the people and systems, and generated a five-step plan.
It assembled five ephemeral agents, ran them, and produced a structured brief, tasks with owners, open blockers, and a P0 security incident. Buried in the thread, an engineer had pasted a plaintext service-account credential. It scored it CVSS 9.8 and wrote a full remediation runbook. No one told it to look for security issues. It reasoned that it mattered, and led with it.
Eight primitives.
The platform builds itself.
Every operable concept is a versioned, frozen, auditable row, not code. A new agent is a new row; a new system, a connector. AI-enable a system in days of metadata, not weeks of code.
Versioned, templated LLM instructions
A capability contract, inputs, outputs, side-effects, approval flag
A named composition of tools with explicit I/O and rollback
Persona + prompt + tools + skills + knowledge + policy
Triggered sequences, cron, event, or manual
Catalog-first definition of an external system
What the system is trying to achieve, with benchmarks
Bounded RAG scope, store, filter, permissions
Nine passive streams.
Zero extra effort.
You already generate the signal, 200+ messages a day, 5-10 meetings. The system extracts ~65% of what it needs from work that’s already happening. These are the planned streams; retention-related signals are roadmap only.
A decision log, built automatically, who decided what, when, reversible or not.
Every promise captured, then tracked to completion or escalation.
Repeated asks and escalation language surfaced in real time, not at the retro.
Shifts in tone, volume and participation, planned as a roadmap signal, not delivered today.
Concern and warmth read from client meetings and internal chatter.
Calendar and presence reveal where attention goes versus where it should.
All signal clustered by topic, “65% on firefighting, 5% on strategy.”
Who talks to whom, hubs, bridges, isolated nodes, key-man risk.
Patterns across training, tenure and outcomes, surfaced as roadmap signals.
The techniques
doing the work.
A causal graph, a planner, an evaluation harness, a temporal memory model and a multi-layer safety pipeline, working together.
A LangGraph supervisor + CrewAI crews route intent and dispatch ephemeral teams generated per task, not pre-wired.
A Neo4j graph models cause→effect with confidence-scored chains, why delivery slipped, not just that it did.
A request compiles into a validated execution graph; a failed step triggers a replan, not a restart.
Temporal facts answer “what was true at time T”, reasoning over how state evolved, not just today.
Qdrant fuses dense + sparse search and LLM-reranks, precise recall across organisational knowledge.
Outputs scored on faithfulness, relevancy and goal accuracy against golden sets, with A/B prompt tests.
A LiteLLM gateway routes by complexity across model tiers from the configured model provider, small to classify, larger to analyse and reason.
Temporal wraps every chain, a crash at step 4 of 7 resumes at step 4. Autonomous work survives failure.
Restricted content is dropped before any model sees it; PII is detected and encrypted at rest.
Ambiguous entities are held for review, never guessed. A wrong attribution can corrupt the graph for weeks.
A system-level memory of what worked and what failed feeds every future assembly decision.
Every operable concept is a versioned, frozen, auditable row, not code. The platform extends itself, under approval.
From cutting the noise
to running the loop.
One system, three depths of help, earned in that order. It starts by giving everyone their time back, and grows into the executive layer you could never afford.
Cut the noise
It reads everything so your team doesn’t have to. 50,000 words of daily Teams signal become decisions, commitments and blockers, surfaced, not buried.
Every employeeA working layer in Teams
A scoped AI that preps your meetings, drafts timesheets from observed work, chases the commitments made to you, and answers questions about the business with cited evidence.
Every employeeAn autonomous partner
It sets goals, plans them, runs the agents, measures impact and adjusts, you hold the approvals. The leadership layer you could never staff, running 24/7 under governance.
Leadership33 specialist agents,
in 7 tiers.
One agent, one domain. Signal flows up the tiers, from raw ingestion through autonomous thinking to governed execution.
Trust is earned,
not demanded.
Autonomy isn’t a switch you flip, it’s a ladder the system climbs by proving accuracy. External writes are designed to wait for human approval, with auto-approve switched off for pilots. One-way doors are designed never to auto-execute.
Observer
Month 1-2Reads everything. Surfaces insight. Humans do all the thinking.
Gate: observations accurate >80%
Advisor
Month 3-4Diagnoses root causes and patterns. Drafts for human review.
Gate: diagnoses validated >70%
Assistant
Month 5-6Proposes objectives, designs activities. External writes are designed to go through an approval card.
Gate: recommendations succeed >60%
Partner
Month 8+Auto-executes reversible work within boundaries you set.
One-way doors always need a human
What it is built to deliver,
role by role.
Every target is tied to a mechanism, to be measured against real data during the first enterprise deployment. These are design targets, not achieved results.
A product, a framework,
then an advisor.
The same 8 primitives that let AI CompMate build itself are designed to outgrow it.
The thinking layer
Today: a governed morning brief in Microsoft Teams, which is the only chat platform supported. The autonomous loop, the specialist agents, approval gates and measurable quality are target design, in development. First enterprise client: an enterprise software company.
Embeddable framework
The 8 primitives become a library and runtime another team can drop into their own product, chat-first AI against their own data and tools, with governance built in.
Auto-discovery advisor
Point it at an existing system. It identifies which workflows are AI-amenable and proposes the blueprint shapes. The framework helping build the framework. Humans still ship.
Built to be owned.
Plugged into your tools.
Built from open-source components and designed to be self-hosted; the only paid dependency is the LLM. Agents reach external systems only through a secured, audited boundary.
Want a thinking layer
for your company?
AI CompMate is in active development for its first enterprise client. Tell us how your team works today, and we’ll show you what it would read, what it would propose, and where you’d hold the yes.