Glass, Intelligence, Engine.

Three layers, one state. The interface never holds anything the reasoning layer cannot see, and the reasoning layer never decides anything the execution layer cannot carry out. That is the whole trick, and it is why the system compounds instead of fragmenting.

Kimbodo Intelligence decides how hard to think before it thinks.

Sending every request to the largest available model is the most expensive way to be wrong slowly. Instead, a small, fast gatekeeper model reads each turn first and classifies it — SIMPLE, AGENTIC or COMPLEX — and the harness routes accordingly. Greetings and lookups never touch a reasoning model. Multi-step work with tools goes to the agentic tier. Architecture and hard analysis escalate to deep reasoning. Prompts under fifteen characters bypass classification entirely and go straight to the fast path, because nobody should wait on a router to say "thanks".

• Tool namespacing with allow and deny globs, so an agent only ever sees the tools its job requires
• A hard per-turn tool budget that protects accuracy as the catalog keeps growing
• Context-aware tool subsetting driven by what the user is actually looking at
• Schema hardening that caps nesting depth and strips keywords a given provider cannot parse
• Automatic escalation to a deeper tier when a turn starts failing its tool calls

Four providers. Every frontier model. No lock-in.

The reasoning layer is provider-neutral by construction. Anthropic, OpenAI, Google Vertex and local Ollama all sit behind one adapter interface, and the catalog spans the full range from nano-class routers to the largest reasoning models available. When a provider rate-limits, the request backs off and fails over to another provider mid-conversation without the user noticing. When a new model ships, it is a catalog entry, not a rewrite.

• Per-agent allowed-model lists, so a customer-facing agent cannot silently escalate to an expensive tier
• Rate-limit resilience with exponential backoff, error logging and cross-provider failover
• Encrypted credential store with per-provider rotation
• Spend tracked per run, per step and per production, with monthly budget ceilings that warn then hard-stop

Kimbodo Intelligence has its own seat at the company.

The intelligence is not handed an API key and told to behave. Kimbodo Intelligence holds a real workspace identity, with granted scopes, an audited send-as policy, provisioned Drive folders and a routing table for inbound mail. When Kimbodo Intelligence drafts an email as you, that is a policy decision someone made and can revoke. When Kimbodo Intelligence files a document, it lands in the folder structure your team already uses. Actions that matter queue as pending confirmations in the portal until a human approves them.

Everything Kimbodo Intelligence can actually do.

Not integrations on a logo wall — callable functions, each with a typed schema, a permission scope and an execution guard. This is the live catalog, grouped by namespace.

Kimbodo Intelligence remembers like an organisation, not like a chat window.

Memory is a graph, not a transcript. Every memory is a typed node with an embedding, scoped to a tenant, a space, a group and an agent, carrying its own relevance score and its own decay rate. Related memories are joined by edges. Facts are extracted and stored separately, so a durable truth about a customer is not buried inside the conversation where someone happened to mention it.

Kimbodo Intelligence reads the industry so nobody has to.

A monitoring layer watches configured sources — feeds, APIs, URLs and rendered pages — on schedules from every fifteen minutes to once a day, with failure tracking and stale-feed detection so a silently dead source is caught rather than assumed healthy. Everything fetched enters a work queue, gets de-duplicated against what has already been seen, and is processed in chunks into observations and summaries, with cost tracked at every step. A premium model then writes the final report over the summaries alone, and it lands as a draft for a human to approve before anything publishes.

1. Monitor Configured workflows poll their sources on schedule, tracking failures and flagging feeds that have gone quiet.
2. Fetch and de-duplicate A durable work queue pulls each source, hashes the content, and drops what the system has already read.
3. Process Long material is chunked and reduced into structured observations and summaries, with spend recorded per step.
4. Report A premium reasoning model writes the briefing from the summaries, keeping its sources attached.
5. Approve and publish Nothing goes live unreviewed. Approval fires an event that the distribution pipeline is listening for.

Operators run the whole pipeline from a twelve-screen console: approvals, dashboard, workflows, sources, job runs, documents, observations, summaries, queue, logs, source status and settings.

A publishing studio that happens to have no staff.

When a briefing is approved, it becomes a candidate. From there the system decides whether it deserves a production, writes the script, performs the narration, renders the video, publishes it, links it back into the site, and then measures whether it worked — and feeds that answer back into how Kimbodo Intelligence scores the next one. Every gate that faces the public requires a human to say yes.

1. Eligibility A thirteen-rule engine screens each candidate on age, length, source quality, category, duplicate topics, whether a video already exists, and whether it makes claims too sensitive to narrate.
2. Trend research Quota-aware, cached trend collection generates three to seven query variations per article and measures view velocity, freshness and saturation.
3. Weighted scoring Nine weighted components plus penalties produce a score — and a plain-language explanation of why it scored that way, so a human can disagree with reasons.
4. Selection One article per day, chosen by weighted random among the finalists, with topic, company and category cooldowns to stop the channel repeating itself. Pin, exclude and produce-now overrides are always available, and every selection run is audited.
5. Script Generated with versioning and chapter splits, then validated for placeholders, stray URLs and length before a human edits and approves it in-panel. Monthly model spend warns, then hard-stops.
6. Narration A provider-neutral text-to-speech layer performs the script section by section with per-section retries and a pronunciation dictionary, falling back across providers and finally to manual upload.
7. Production Sections are concatenated with chapter pauses and normalised to broadcast loudness. Branded scene cards render into a 1080p cut with Ken Burns motion and fades, captions burned in or shipped as a sidecar, and a branded thumbnail.
8. Publish Resumable private upload with a channel-identity safety check, thumbnail, captions and playlist companions, released now or on a schedule — only after approval.
9. Link back The video embeds into its source article alongside a "listen to this briefing" player, with a distribution map of every placement that can attach to posts published later.
10. Learn Daily performance metrics on a decaying cadence roll up into per-category multipliers that feed straight back into candidate scoring. The channel tunes itself.

Underneath: an atomically-claimed job queue with retries, light tasks on cron and heavy rendering on a niced worker, pause switches for everything, rendering and publishing independently, and an encrypted credential store.

Kimbodo Intelligence measures what it did, then changes what it does.

Measurement is not a dashboard somebody opens on Fridays. Engagement, audience behaviour, campaign performance and publishing outcomes are collected first-party, rolled up on a decaying cadence, and wired directly back into the scoring that decides what gets produced next. The loop is closed by design.

• First-party engagement and audience analytics owned end to end, with no dependency on a third party to answer a question about your own traffic
• Per-asset performance tracking across video, article and social placements
• Per-category performance multipliers fed back into production selection
• Attribution from inbound traffic back to the specific post, video or campaign that produced it
• Monthly spend rollups per pipeline, so cost per published asset is a number, not a feeling
• Agents can query the analytics directly and answer questions about performance in conversation

Where the team and the intelligence do the work together.

A project is the unit of context. Put the people, the threads, the files, the company record and the deal in one place, and the agent stops being a stranger you have to brief every morning. It reads the project it is standing in — who the customer is, what has been promised, what was said last week, which documents exist — and it acts from there. The same conversation that plans the work can also send the mail, book the meeting and draft the proposal, and nothing consequential leaves the building without someone saying yes.

Proposals and documents that show their work.

A real authoring workspace with an agent living inside it. It knows the difference between a document and a proposal: a document is prose with structure, while a proposal carries scope, deliverables, pricing, assumptions, a delivery plan and a timeline, and is assembled from the company record, the deal, the project history and the templates your team already approved. Ask it to draft and it does not overwrite your work — it proposes changes as tracked redlines you accept or reject line by line.

The intelligence is wherever the work is.

There is no "AI section" of the product to visit. The same reasoning layer, the same memory and the same tools surface everywhere work happens, scoped to whatever you are looking at.

Most of what Kimbodo Intelligence does, nobody asked for that morning.

The system is mostly autonomous. Work arrives on a schedule, in response to an event, or because someone asked — and all three paths run through the same queue, the same permission model and the same audit trail.

And Kimbodo Intelligence provisions the infrastructure too.

Kimbodo Launch is the deployment arm, running on its own infrastructure and driven by the same intelligence. It stands up production-grade environments across AWS, Azure and Google Cloud in minutes rather than weeks, with consistent architecture, governance and access control from the first deployment. Connect a cloud account, agree the architecture standards, and launch.

• Multi-cloud with a consistent architecture and no lock-in
• Governance, access control and compliance built in from day one
• Standardised infrastructure across teams, regions and environments
• Best-practice architecture applied automatically, not documented and hoped for

The page you are reading was written by the system it describes.

This is the part that tends to stop conversations. Kimbodo Intelligence does not just operate the business — Kimbodo Intelligence extends itself. Kimbodo Intelligence writes its own modules, builds its own public pages, monitors its own health, migrates its own data, backs itself up, and files its own roadmap entries when Kimbodo Intelligence finishes something. A fleet of command-line agents in the build plane does the engineering, and the running system does the operating, and the two are the same system wearing different hats.

Kimbodo Intelligence keeps its own roadmap.

This is rendered live from the system's own roadmap database, right now, as you load the page — every program and the capability shipped underneath it. The overwhelming majority of these entries were written by the intelligence itself as Kimbodo Intelligence completed the work, not typed in by a product manager afterwards.

Six things Kimbodo Intelligence does without being supervised.

Capability lists are easy to write and hard to believe. Here is the same system described as work actually getting done, start to finish.