Arito ads

Arito is one of Israel’s 25 Most Promising Startups of 2026. We’ve been selected by N12 News Israel, in collaboration with LeumiTech and Valley Bank, as one of the companies shaping what’s next in Israeli tech. The recognition comes at an exciting point in our journey. At Arito, we’re building AI that can do real analytical work across the tools and data businesses already rely on, from complex spreadsheets to enterprise systems. Our focus is not just on making AI smarter, but on building the infrastructure around it that makes complex business analysis reliable, contextual, and usable in practice. Being included among this group of companies is a meaningful recognition of that direction and, most importantly, of the team building it every day. Thank you to N12 News Israel, LeumiTech, and Valley Bank for the recognition, and congratulations to all the companies selected for this year’s list. We’re just getting started. https://arito.ai/

Here's the knowledge base architecture we currently run in production at @Arito, what we learned from building it, and why it helps us top benchmarks. ✦ What a knowledge base actually is Not RAG. The agent's governed understanding of your data: definitions, entity mappings, join recipes, plus two folders almost nobody builds: contradictions/ and open questions/. Ours is plain markdown in git, one repo per workspace. Every change is a commit: attributed, reviewed, reversible. ✦ This is the agent's memory LLMs are stateless. The knowledge base becomes the agent's de facto long term memory. What one user teaches today, everyone benefits from tomorrow. We're giving agents memory: readable, editable, auditable, and as a git it also has a timeline. Memory with timeline, just like human memory. ✦ Version control, for free The knowledge base IS a git repo, so version control comes free. Every fact carries who, why, since when; definitions are superseded, never erased. The part people miss: the agent has access to this history too. It can reason over how your business evolved. Memory with a timeline. ✦ The feedback loop Usage is the investment. Every interaction feeds a knowledge agent: Interaction → Candidate claim → Triage → Risk score → Committed page Rules only, never values ("enterprise = ACV > $100k" persists; "Q3 was $4.2M" doesn't). Rejections become memory: "a human rejected this, do not reintroduce." ✦ The auto update threshold Autonomy is a threshold, not a toggle. Each claim is scored on: Blast radius: downstream impact Corroboration: surfaced in multiple people's work? Proposer trust (see below) Clears the bar → auto applies. Below → human review. ✦ The credit score Born from a real failure mode: two users, conflicting definitions. Treat all feedback equally and knowledge becomes whoever spoke last. So: one trust account per user × space. Accepted contributions raise it; admin overrides lower it. Trust unlocks graduated scopes: propose → insert → update. Deletion + conflict resolution stay human only at ANY trust level. ✦ Dreaming Two execution modes: immediate (right after each interaction) and dreaming (a nightly pass over the day). Dreaming catches what per interaction processing can't: three people defining churn differently, the same question asked four times. ✦ The flywheel Users work → agent explores expensively once → validated discoveries persist → claims scored and governed → dreaming consolidates → the next question is cheaper and more consistent. Knowledge compounds with usage instead of decaying. Memory that gets sharper the more you use it. This runs in production today. Happy to go deeper in the comments.

Everyone and their sister is talking about knowledge bases / company brains / wikis. But is anyone talking about how to actually evaluate these? We built a benchmark methodology for it. The idea is simple: if the system really learns a database through use, it should get better at questions it has never seen. How it works: 1. We take a large public question suite (SPIDER, BIRD, BEAVER, etc.) and split every database's questions into two parts, one for training and one held out. The split never changes. 2. The agent works through the training part and we distill its traces and verdicts per question. A simulated user answers the agent's clarification questions, so that feedback becomes part of the learned knowledge as well. 3. Those traces are then turned into a knowledgebase for each database: the semantics, structure, relationships, business logic and quirks it picked up along the way. This is the same component that builds a customer's knowledge base, not something we made for the benchmark. 4. We then run the held out questions twice. One run gets the knowledgebase, the other doesn't. Everything else is identical. 5. Scoring is deterministic, no LLM judge. We execute the ground truth query and compare the returned data to the agent's data. The difference between the two runs is the effect of the knowledge, measured on questions the system never saw while learning. Early results are consistent across suites, with double digit relative gains on the hardest one. At Arito this sits on the research side of the house. We treat the knowledge layer as an open research problem, and this benchmark is how we know whether we are actually making progress.

Here's the knowledge base architecture we currently run in production at Arito, what we learned from building it, and why it helps us top benchmarks. 📚 𝗪𝗵𝗮𝘁 𝗮 𝗸𝗻𝗼𝘄𝗹𝗲𝗱𝗴𝗲 𝗯𝗮𝘀𝗲 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗶𝘀 - Not RAG. The agent's governed understanding of your data: definitions, entity mappings, join recipes, plus two folders almost nobody builds - contradictions/ and open-questions/. Ours is plain markdown in git, one repo per workspace. Every change is a commit: attributed, reviewed, reversible. 🧠 𝗧𝗵𝗶𝘀 𝗶𝘀 𝘁𝗵𝗲 𝗮𝗴𝗲𝗻𝘁'𝘀 𝗺𝗲𝗺𝗼𝗿𝘆 - LLMs are stateless. The knowledge base becomes the agent's de facto long-term memory. What one user teaches today, everyone benefits from tomorrow. We're giving agents memory: readable, editable, auditable, and as a git it also has a timeline. Memory with timeline - just like human memory. 🕰️ 𝗩𝗲𝗿𝘀𝗶𝗼𝗻 𝗰𝗼𝗻𝘁𝗿𝗼𝗹, 𝗳𝗼𝗿 𝗳𝗿𝗲𝗲 - The knowledge base IS a git repo, so version control comes free. Every fact carries who, why, since-when; definitions are superseded, never erased. The part people miss: the agent has access to this history too. It can reason over how your business evolved. Memory with a timeline. 🔄 𝗧𝗵𝗲 𝗳𝗲𝗲𝗱𝗯𝗮𝗰𝗸 𝗹𝗼𝗼𝗽 - Usage is the investment. Every interaction feeds a knowledge agent: Interaction → Candidate claim → Triage → Risk score → Committed page Rules only, never values ("enterprise = ACV > $100k" persists; "Q3 was $4.2M" doesn't). Rejections become memory: "a human rejected this, do not reintroduce." ⚖️ 𝗧𝗵𝗲 𝗮𝘂𝘁𝗼-𝘂𝗽𝗱𝗮𝘁𝗲 𝘁𝗵𝗿𝗲𝘀𝗵𝗼𝗹𝗱 - Autonomy is a threshold, not a toggle. Each claim is scored on: Blast radius - downstream impact 👥 Corroboration - surfaced in multiple people's work? Proposer trust (see below) Clears the bar → auto-applies. Below → human review. 💳 𝗧𝗵𝗲 𝗰𝗿𝗲𝗱𝗶𝘁 𝘀𝗰𝗼𝗿𝗲 - Born from a real failure mode: two users, conflicting definitions. Treat all feedback equally and knowledge becomes whoever-spoke-last. So: one trust account per user × space. Accepted contributions raise it; admin overrides lower it. Trust unlocks graduated scopes — propose → insert → update. Deletion + conflict resolution stay human-only at ANY trust level. 🌙 𝗗𝗿𝗲𝗮𝗺𝗶𝗻𝗴 - Two execution modes: immediate (right after each interaction) and dreaming (a nightly pass over the day). Dreaming catches what per-interaction processing can't: three people defining churn differently, the same question asked four times. 🚀 𝗧𝗵𝗲 𝗳𝗹𝘆𝘄𝗵𝗲𝗲𝗹 - Users work → agent explores expensively once → validated discoveries persist → claims scored and governed → dreaming consolidates → the next question is cheaper and more consistent. Knowledge compounds with usage instead of decaying. Memory that gets sharper the more you use it. This runs in production today. Happy to go deeper in the comments. #knowledgebase #agentmemory #feedbackloop #arito

A frontier model can reason about a spreadsheet. Production-grade execution is a different engineering problem. Arito puts a purpose-built agent harness around the model: spreadsheet-native tooling, visual inspection, Excel’s real calculation engine, long-horizon context management, and post-execution verification. The agent doesn’t just generate an answer. It can inspect the workbook, reason across formulas and dependencies, execute changes, observe the calculated state, and verify the result. That architecture is what turns model capability into reliable spreadsheet execution. Arito ranked #1 on SpreadsheetBench v2. The model sets the ceiling. The harness determines how much of it you can actually use. → Explore Arito https://arito.ai/

What does it actually take for AI to work reliably on real business models? Not a better prompt. And not just a stronger model. It takes an architecture that can reason through spreadsheet logic, execute real calculations, preserve context, and verify the result. We built that architecture into Arito. SpreadsheetBench v2 put it to the test. → Explore Arito https://arito.ai/