TwoSetAI Workshop #5. Ahmet İlten, founding engineer at Sentience (agent architecture and quality), walks through their personal-agent product and the four principles his team arrived at the hard way. Benjamin Carsley was scheduled to cover the voice/tone half but was out sick, so the session is Ahmet solo plus Q&A with host Angelina Yang. (48 minutes.) Sentience is a New York startup founded in 2025 by Sam Kececi, backed by Bain Capital Ventures and South Park Commons; it left closed beta the week after this recording.

What the product is

  • A digital simulation of a person rather than a general assistant — the claim he opens with, then tries to earn
  • Three layers: a home base that proactively surfaces what it knows about you, a memory layer built from connected sources, and a personal profile covering how you reason, your preferences, your principles
  • It gets its own email address and phone number, so you can talk to it like a contact — and other people can too
  • The pitch is that the answer is specific to you: instead of asking a one-size-fits-all agent for a judgment call, he asks a colleague’s Sentience and gets that colleague’s actual reasoning, context and priorities back
  • Demo: “ship a user-research pass or ship and iterate?” Sam’s Sentience says ship the smallest real version, then put it in front of five users immediately — matching his observed pace. A generic model returns the balanced both-sides answer, which he calls useless

The trap: complexity as a mask

  • The common first instinct is a very complex system — he shows an Unreal Engine gameplay-loop graph as the visual joke. Node-and-edge agent frameworks grow exponentially messier with every feature, and whiteboarding them is satisfying in exactly the way that is dangerous
  • Why it hurts: all that architecture masks the actual problem you need to solve
  • His example: storing the latest state of some topic. You can write it to a markdown file, or you can build an entity graph with relationships, a recency algorithm and a relevance score. The second version is a mask over “you need to store information and serve it at the right time”
  • Every net-new layer should be justified as a mask that filters what actually matters — sometimes entity systems are right, but Sentience only got there after shipping the simpler version and proving it did not work
  • The precedent he cites is coding agents: indexing the whole codebase into a vector database with entity graphs was the original idea, and what won was grep — plain keyword search over files. Claude Code was heavily grep-based, Cursor moved to keyword search, and there is research showing how strong plain keyword retrieval gets you

Principle 1 — keep it simple, stupid

  • His reference is grugbrain.dev, which he tells the audience to read and internalize: the site assumes you are dumb and will forget everything, which forces you to build things simple enough to survive that

Principle 2 — start from the user experience, work backwards to the technology

  • Attributed to Steve Jobs; the working version at Sentience is: I need to surface your values, capture them somewhere, and serve them at the right time. How do I make that possible?
  • The wrong order: build the complex agent, discover it needs a memory layer, then try to figure out how to make users want the complex system you already built
  • Applied to third-party memory systems: they publish benchmark wins like “5% better retrieval,” and the question to ask is better at retrieving what? The success criterion is not a benchmark, it is that the agent surfaces your values, preferences and expertise

Principle 3 — see the monster at all times

  • The monster is the system prompt and the context window. Tokens in, tokens out: every fix adds a section
  • The whack-a-mole he describes: timestamps are wrong, so you add a timing section; email search breaks, so you add rules for email search; a tool description grows; an identity instruction grows. Every new instruction devalues all the others
  • John Carmack’s rule for state changes — you should be made constantly aware of the full horror of what you are doing — applies directly: keep one place where you can see the entire input
  • If 50 prompt components get assembled in different places at different times, nobody ever sees the shape of the whole thing. See it, trim it, get it into a shape the agent can actually perform in

Principle 4 — run evals first

  • LLMs are not deterministic. Pre-LLM code does one thing; an LLM lets you fix the em-dash problem and break the dates, fix the dates and confuse a fact from three months ago
  • Every change affects every other change — that is the whole argument for evals
  • Keep it simple: a set of test cases you run after each change to confirm the answers have not gone terrible. That is the entire contract
  • The method is secondary — LLM-as-judge, you judging by hand, or hired raters all work. What matters is that you do it, and that you pick the method with the context of your own project
  • Without it: you tell the agent something is fixed, a user comes back, and it was never fixed

Q&A: privacy, harnesses, memory

  • Privacy is the hardest trade-off. Engineers have a development database, not production — they cannot go look at your data or delete a specific memory for you. Logs are stripped of personal detail (a chat existed at this time), and to reproduce a bug they recreate it on their own accounts or ask for a screenshot. Some issues simply cannot be chased down, and they accept that cost
  • Data sovereignty: legal ownership sits with the user, and deleting the account deletes everything. He contrasts this with ad-funded platforms where your data is the product; Sentience has no ads, so the user is the customer
  • Harness: for a company, own your harness. For personal use, an existing harness is fine
  • Memory architecture: theirs is largely markdown files with keyword search. Vector databases are good for indexing messages and images; markdown is better for persistent state and latest values. No Postgres tables or structured data sources beyond connectors like Google Sheets — it is a consumer product and deliberately has few knobs
  • Modular-vs-opinionated trade-off: connect-to-everything loses control of the experience. Developers want Neovim-style configuration; most people want something well made and intuitive, and it is very hard to be both

Working at the frontier

  • He runs six to ten agents in parallel and coordinates them
  • Decisions collapse: what takes months at a large company takes them a day or half a day
  • Directly responsible individual is the operating principle — if he owns the iMessage integration, he makes the judgment calls and owns delivery, discussing only with the people affected
  • Meetings: zero on most days, around three on a heavy one

“The complex solution needs a justification.”

If there is one line to take to your own agent project, it is that one — and the companion rule from principle 3, that you cannot fix a prompt you cannot see the whole of.