The intelligence inside our agentic harness—and how it gets smarter, not dumber, over time

1. Baling wire and duct tape

If you run a small business, you have heard the advice for years. Buy the best app for each job—one for customers, one for projects, one for invoices, one for scheduling—and connect them. When the connections break, add another integration. When nobody can find anything, add a dashboard.

The results are well documented. In one survey of U.S. businesses with 10 to 99 employees, the typical company ran about ten separate business tools, spent roughly $10,000 a month on software, and wasted about $3,000 of it on apps nobody used. Teams reported spending around 25 hours a week re-entering or reconciling data between those apps, and 91% said the manual reconciliation lowered their productivity.¹ (That survey comes from a software vendor, so read it as directionally right rather than exact.) Researchers watching office workers found them switching between applications about 1,200 times a day, losing close to four hours a week just reorienting.² And the businesses that grow tend to be the ones that escaped the patchwork: 66% of growing small businesses report integrated systems, against 32% of declining ones.³

Now the same advice has arrived for artificial intelligence. Automation platforms advertise AI agents that work across thousands of apps. Chat assistants plug into your tools through connectors. A growing chorus suggests you skip the software altogether and have an AI build you your own CRM over a weekend. It is the old strategy with a new engine: you are still the systems integrator, only now the thing you are integrating can also make things up.

It is not working for most small businesses, and the numbers say so plainly:

• Among the growth-minded owners in Goldman Sachs' 10,000 Small Businesses program, 76% use AI, but only 14% have fully integrated it into their core operations.⁴
• McKinsey's 2026 survey found large organizations scaling AI agents jumped from 27% to 40% in a year. Smaller organizations stayed flat at 22%.⁵
• U.S. Census data shows AI use among firms with fewer than 20 employees did not change significantly from late 2025 to spring 2026.⁶
• MIT's widely cited (and widely debated) study of enterprise AI reported that about 95% of organizations saw no measurable return, and named the cause: “brittle workflows, lack of contextual learning, and misalignment with day-to-day operations.” ⁷
• Gartner predicts more than 40% of agentic AI projects will be cancelled by the end of 2027.⁸

None of this is because owners are doing it wrong. It is because the approach asks a ten-person company to do what large enterprises with IT departments struggle to do: make a dozen systems that were never designed to agree behave like one business.

2. Why bolting tools onto an agent makes it dumber

To see why, it helps to know what an AI agent actually is. At its core is a language model—the part that reads and writes. Around it sits software that gives the model tools: the ability to look up a customer, create a task, send an email. On every step the model reads everything placed in front of it—its instructions, the conversation so far, the results of earlier lookups, and a written description of every tool it might use—then decides what to do next. That working space is called the context window.

Context windows are large now, but attention inside them is not free. Research across eighteen leading models found that performance degrades as input grows, even when the task itself stays equally hard.⁹ In another benchmark, eleven of thirteen models that advertise very long context windows fell below half of their short-context accuracy by the time the input reached 32,000 tokens (about 24,000 words).¹⁰ Models also reliably lose track of information buried in the middle of long inputs.¹¹

Tools make this worse, because their descriptions ride along on every step whether they are needed or not. Anthropic measured one popular connector's 35 tools at roughly 26,000 tokens, and reported setups where tool definitions alone consumed 134,000 tokens.¹² When researchers grew a tool catalog from 8,000 to 120,000 tokens, models got between 7% and 85% worse at using them.¹³ In another study, loading every tool at once left the model choosing the right one only 13.6% of the time, against 43.1% when it was shown only the relevant few.¹⁴OpenAI's own guidance is to keep fewer than twenty tools available at the start of a turn.¹⁵

“Have you heard stories like: the more tools you give an agent, or the more MCP servers you hook up to it, the agent gets dumber? People try to give an agent 500 tools and the agent becomes stupid.”
— Alexander Ford, on a client call, August 2026

There is a second, quieter failure. A patchwork of apps has no shared meaning. The “customer” in your CRM, the “client” in your invoicing tool and the “account” in your project software may be the same company, or may not. People resolve that from memory. An agent has to guess, and it guesses fluently. Research on business data bears this out: when language models answer questions against a well-defined semantic model of the data instead of raw tables, accuracy rises sharply—in one 2026 benchmark from 90.0% to 98.2%—and the failures change character. As the authors put it: “With text-to-SQL, failure looks like a plausible but incorrect answer. With the Semantic Layer, failure looks like an error message.”^16,17

The more a general-purpose agent is connected to, the less of its attention is left for understanding any one thing it is connected to.

3. The other path: an opinionated system with a harness built for it

We build Telos, the software inside the Accelerator OS, and we took the opposite approach. Instead of connecting an agent to everything, we gave it one coherent place to work, and invested heavily in the part of the system most people never see: the harness.

The model is the brain. The harness is the body.

A harnessis everything around the language model that turns it into something useful: its identity and rules, the tools it can use, how those tools are described, what it remembers, how its working space is kept clean, and the guardrails that stop it doing harm. The model decides; the harness decides what the model sees when it decides, and what its decisions are allowed to do. The best harnesses, in our experience and Anthropic's, are built from simple, well-understood patterns rather than elaborate frameworks, with most of the effort spent on the tools themselves.¹⁸

Because the harness carries the intelligence of the system, the model underneath is replaceable. Telos works with a range of frontier models, and when a better one arrives, every capability we have built carries over to it on day one.

An opinionated model of the business

The first design decision is the least technical. Telos has an opinion about how a business is shaped. Strategy follows a one-page strategic plan: a foundation (purpose, vision, a long-range goal), multi-year horizons, strategic thrusts, an annual plan, initiatives, and quarterly priorities we call rocks. Customers, deals and offers live in one place. Work is projects and tickets with owners, checklists and dependencies. Knowledge lives in a searchable library connected by a graph of typed relationships. Every call, email, meeting and change lands on one activity timeline.

For a person, that structure removes guesswork. For an agent, it is the difference between reading a map and reading a pile of receipts. When Sapience is asked how the quarter is going, it does not scrape three apps and hope the names line up. It reads rocks that are typed, owned, dated and linked to the initiatives they serve—and its strategy tool can point out what the plan is missing, such as a rock no initiative depends on or a thrust with no initiatives beneath it.

Picture a fireplace retailer on a busy Saturday. A couple walks in looking at a gas insert. Afterward the salesperson types one sentence: “Log the Hendersons from this morning, they want a quote on the gas insert, and remind me to follow up Thursday.” Because Telos already knows what a contact, a deal and a task are and how they connect, the agent finds or creates the contact, opens the deal in the right pipeline, sets the task, and records what happened—on the same records the rest of the team works from. Ask it next week to draft a follow-up, and it writes from what actually happened, not from what it half-remembers.

Many tools, few in view

The second decision is how capability is exposed. Sapience can use 145 tools today, grouped into 11 categories—strategy, sales, operations, knowledge, communication and so on. But on any given step it sees only 27: the readers and finders that almost every conversation needs, plus a tool for loading more. When a request calls for something else—updating a strategic plan, merging duplicate contacts, proposing meeting times—the agent loads that category, uses it, and keeps it for the rest of the conversation.

Think of a good employee handbook. It opens with a table of contents, not with every policy printed on the first page. You read the chapter you need when you need it. Anthropic calls this progressive disclosure, and its own measurements show why it matters: letting the model search for tools instead of carrying them all raised tool-use accuracy on its evaluation from 49% to 74% for one model, while cutting token use by 85%.^12,19

The same principle applies to the instructions that come with tools. Each category carries a short operating protocol—how to handle duplicates, when to confirm before acting, which record is the source of truth—and those protocols load only with the category they govern. The agent reads the rules for booking meetings when it is booking a meeting, not while it is summarizing a sales call.

One definition, every agent

The third decision is where most of the compounding comes from. Every tool in our system is defined exactly once, in a single registry: its name, its inputs, its description, the category it belongs to, and which agents may use it. Sapience, our own internal agent (Xavier), and the connections our engineers use all read from that one registry. Sapience does not define a single tool of its own; an automated check fails the build if anyone tries.

That matters because tool descriptions are not documentation. They are instructions to the model. We write them under a standard we hold ourselves to: the reader is a model under token pressure, every word costs attention, and the author is programming the agent, not describing a product. In our experience, ten or twenty well-chosen words in a tool description can completely change how an agent behaves. Anthropic reports the same: in its own work, it spent more time optimizing tools than the overall prompt.^18,20

So when we sharpen one description—because an agent reached for the wrong tool, or skipped a step—that improvement reaches every agent the tool is granted to at once. We run our own company on the same harness. Every lesson our team learns operating Measurable Genius becomes a better tool definition, and every business on Telos inherits it.

Keeping the working space clean

Long conversations are where most agents quietly degrade: each lookup leaves its full results behind, and after an hour of real work the model is wading through pages of stale output. Our harness treats context as an asset with an opportunity cost.²¹

• Old results are folded away, not lost. When a conversation is replayed to the model, only the most recent round of tool results is kept in full. Older ones are replaced with a one-line note saying what they were and how to fetch them again if needed.
• Long conversations are compacted.As a conversation approaches the model's limit, earlier stretches are summarized while the most recent tool exchanges stay word-for-word. The complete transcript is always kept; only the model's working copy is condensed.
• The stable parts are cached.The agent's identity and its core tools are kept byte-for-byte identical from step to step, so the model provider can reuse them instead of reprocessing them. That makes each step faster and cheaper.
• A map, not a dump. At the start of a conversation the agent is told what exists in the workspace—how many records, contacts, companies and deals—not the contents. It retrieves the contents when the question calls for them.

The effect is measurable. Over the last 30 days, the busiest step of the average Sapience run used about 70,800 tokens—roughly 7% of the context available to it. The agent works with room to think.

Look it up; don't remember it

A general-purpose assistant answers from what it absorbed during training and whatever you pasted into the chat. Sapience is built to look things up. It answers from the records in your workspace, and when a search comes back empty it says so rather than filling the gap.

“It doesn't depend on memory. It will always look up the knowledge, it will always look up the specifics, and it will always use exactly the information in the system—never acting from whatever the deal was I did last week.”
— Alexander Ford

The same discipline governs what it does. It may only say it created, changed, searched for or sent something if the corresponding action ran in that conversation and succeeded. A failed action is reported as a failure, not smoothed over. Its operating rules require an explicit yes before anything destructive—deleting or merging records—after the agent has restated exactly what will happen. And when it sends an email or text message, it sends it one-to-one, from the account of the person who asked.

Memory that accumulates in structure

An agent that looks everything up still needs to get to know you. Sapience keeps several kinds of memory, each with a clear job: short operational notes about how your business works, a searchable record of past conversations, profiles of the people it works with, and the knowledge library itself, where plans, processes and decisions are written down and linked. Recorded calls and videos are transcribed and made searchable the same way.

The important word is structure. Most memory is not loaded automatically; the agent retrieves what is relevant when it judges it relevant. Nothing is stuffed into the context just in case. So as your workspace grows, the agent has more to draw on without carrying more on every step. Every plan you write, every call you record and every decision you capture makes the next answer better grounded.

Built to finish the job

Real work takes more than one step. Sapience runs on a durable execution engine we built called Praxis, which saves the state of a run after every step. If a server restarts in the middle of a task, the run picks up where it left off instead of starting over or silently failing. For larger jobs, the agent can hand pieces to up to four focused sub-agents working in parallel, each with its own clean working space, and gather their findings. Guards watch for the ways agents go wrong—repeating the same failing action, or writing in circles—and stop the loop so the agent explains the dead end instead of spinning. You can redirect a run while it is working, or stop it outright.

4. Why it gets smarter, not dumber

Put those decisions together and three loops emerge that run in the opposite direction from a bolted-together stack.

1. Capability grows without clutter. On July 1, 2026, our shared catalog held 147 tools. Today it holds 211. The always-loaded core has stayed small throughout, so each new tool adds a capability without adding a cost to every conversation that doesn't need it.
2. Knowledge accumulates in a shape the agent understands. Because the data model is fixed, what you add this month is as legible to the agent as what you added last year. Nothing needs re-mapping.
3. Every improvement is shared. A better tool description, a new guardrail, a smarter compaction rule—each is made once and reaches every agent and every workspace.

We hold ourselves to measuring this rather than asserting it. On Xavier, our internal agent running on the same harness, we track first-answer resolution: the share of answers people accepted without correcting, re-asking or rejecting them. Over the last 30 days it stood at 97.7%, from 1,560 answers labelled since measurement began in August. Inside Telos, Sapience has completed more than 10,555 runs across 58 businesses since April.