<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Vaishnavi on Medium]]></title>
        <description><![CDATA[Stories by Vaishnavi on Medium]]></description>
        <link>https://medium.com/@vaishnavi180806?source=rss-2983f0f10f19------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*rC3gt0nH4paGz5l8</url>
            <title>Stories by Vaishnavi on Medium</title>
            <link>https://medium.com/@vaishnavi180806?source=rss-2983f0f10f19------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:44:52 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@vaishnavi180806/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Bad Memory Is Worse Than No Memory for AI Agents]]></title>
            <link>https://medium.com/@vaishnavi180806/bad-memory-is-worse-than-no-memory-for-ai-agents-1332f6bb64f1?source=rss-2983f0f10f19------2</link>
            <guid isPermaLink="false">https://medium.com/p/1332f6bb64f1</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Vaishnavi]]></dc:creator>
            <pubDate>Sun, 05 Jul 2026 10:01:58 GMT</pubDate>
            <atom:updated>2026-07-05T11:02:11.291Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0_90AN6OAMevZKjuMJNVMg.png" /></figure><h4>Everyone wants agents that remember. But the real question is: can they forget what is no longer true?</h4><h3>Table of Contents</h3><ol><li>The hidden problem with “just give agents memory”</li><li>Bad memory shows up in small ways first</li><li>The memory layer needs a lifecycle</li><li>What <a href="https://cognee.ai/">Cognee</a> gets right here</li><li>Quick competitor landscape</li><li>What I would build next</li><li>Conclusion</li></ol><p>Everyone is talking about giving AI agents memory.</p><p>And yes, I get it.</p><p>Agents that forget everything are painful to use. You explain the same context again. You upload the same docs again. You remind the agent of the same preferences again. After a point, it stops feeling like an assistant and starts feeling like a very expensive intern with short-term memory loss.</p><p>But the more I thought about agent memory, the more one thing bothered me.</p><p>What if remembering everything is not the goal? What if the real risk is an agent that remembers the wrong thing too confidently?</p><p>Imagine a support agent that remembers an old refund policy.</p><ul><li>A coding agent that remembers a workaround the team removed months ago.</li><li>A sales agent that remembers a discount rule that no longer exists.</li><li>A research agent that remembers an outdated claim and keeps using it in new analysis.</li><li>A DevOps copilot that remembers a temporary fix and treats it like the official runbook.</li></ul><p>That is not “better memory.” That is memory debt.</p><p>And honestly, this is the side of AI memory I think more people should talk about.</p><p>A memoryless agent is annoying. But an agent with bad memory can be worse.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QrHuA3P_oFs-aW1jEUNCxg.png" /></figure><p>A lot of teams already feel this problem in a softer form.</p><p><strong>Glean’s 2026 Work AI Index</strong> says workers spend 6.4 hours a week “botsitting” AI, which includes feeding it context, checking outputs, correcting mistakes, and cleaning up unreliable work. The same report says 69% of AI users admit to shipping work they have not fully verified or cannot confidently stand behind.</p><p>The future of agents is not just about making them remember more. It is about making sure they remember what is still true.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F-yYvR6PgSXK8U-sOtqyHg.png" /></figure><h3>1. The hidden problem with “just give agents memory”</h3><p>The first version of the AI memory conversation is easy to understand.</p><p>Agents forget → So we give them memory.</p><p>Simple!</p><p>But real workflows are not that simple.</p><p>Work changes. Products change. Policies change. APIs change. Teams change. Pricing changes. Runbooks change. Customer status changes. What was true last month may be wrong today.</p><p>That creates a new problem.</p><p>An agent may remember something correctly from the past, but still use it incorrectly in the present.</p><p><strong>Here is a simple example:</strong> A company has a support agent that remembers old customer cases. Six months ago, the refund policy said customers could request a refund within 30 days. Today, the policy changed to 14 days for one product line.</p><p>Now a customer asks: <em>Can I still get a refund?</em></p><p>A memoryless agent might say: <em>Let me check the current policy.</em></p><p>A bad-memory agent might say: <em>Yes, customers can request refunds within 30 days.</em></p><p>It just remembered the wrong version of truth. (That is the danger)</p><p>We usually treat memory as a pure upgrade. But memory has to be maintained. Otherwise, it becomes stale context wearing a useful-looking mask.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KtJOgv8ehrTa_S4ZgCIUAg.png" /></figure><p>This is why “memory” should not mean dumping every conversation, note, and document into a database forever.</p><p>Good memory needs judgment. It needs to know what to keep, what to update, what to trust, what to down-rank, and what to forget.</p><h3>2. Bad memory shows up in small ways first</h3><p>The scary part is that bad memory does not always look dramatic.</p><p>Most of the time, it looks useful. That is why it is easy to miss.</p><p>A<strong> bad-memory agent</strong> may confidently reuse an old product claim. It may repeat a customer preference that the customer changed. It may cite a deprecated API. It may use an old pricing page. It may keep recommending a workaround that was only meant for one temporary incident.</p><p>The agent gives an answer. The human checks it. Something feels slightly off. Then the human spends ten minutes figuring out whether the agent used an old source, a wrong note, or a stale assumption.</p><p><strong>That is botsitting.</strong></p><p>And once agents move into more serious workflows, stale memory becomes more expensive.</p><ul><li>For a customer support team, it can mean giving the wrong policy.</li><li>For a coding team, it can mean bringing back a bug pattern that was already removed.</li><li>For a legal or compliance workflow, it can mean relying on outdated rules.</li><li>For a cloud team, it can mean suggesting a mitigation that no longer matches the architecture.</li><li>For a research workflow, it can mean building a fresh argument on top of stale evidence.</li></ul><p>The pattern is the same everywhere.</p><p>The agent did not fail because it had no context.</p><p>It failed because it had bad context.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wq0ViTvORwgE5yqFxb-MOg.png" /></figure><p>This is why I think the phrase “long-term memory” can be misleading, because Long-term is not enough. Long-term memory also needs cleanup.</p><h3>3. The memory layer needs a lifecycle</h3><p>This is where the Cognee framing becomes interesting.</p><p>Most people talk about memory like it is one action: <strong><em>remember this.</em></strong></p><p>But a useful agent memory system needs more than that. It needs a lifecycle. A simple lifecycle looks like this:</p><pre>remember → store useful context<br>recall → retrieve the right context<br>improve → update memory as new facts arrive<br>forget → remove or reduce stale context</pre><p>That last step is the one people underappreciate, because forgetting sounds like a weakness, but in real systems it is a feature.</p><p>A good agent should forget an outdated price. It should stop using a deprecated API. It should ignore an old workaround after the root bug is fixed. It should not keep treating a temporary exception as a permanent rule.</p><p>In other words, memory is not only about recall. It is about memory hygiene.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9DcQ9zdnDw3m-VkB6H8uHw.png" /></figure><p>This is also why bigger context windows do not solve the full problem.</p><p>A giant context window can hold more text, but it does not automatically know which parts are stale, which parts are current, which parts conflict, and which parts should never be used again.</p><p>More context can also mean more confusion.</p><p>The agent needs a way to retrieve the right memory, not all memories. That is where structured memory becomes important.</p><h3>4. What Cognee gets right here</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5EdXdbClXBbau97UQN7smQ.png" /></figure><p><a href="https://cognee.ai/"><strong>Cognee</strong></a> is useful in this conversation because it does not only frame memory as “save the chat.” It treats memory as structured data that can be searched, connected, improved, and removed.</p><p>Cognee combines vector search with graph-based memory. The simple version is:</p><pre>Vectors help find things that sound related.<br>Graphs help connect things that are actually related.</pre><p>That matters because bad memory often comes from broken relationships.</p><p>For example, this note may be true:</p><pre>Refund window is 30 days.</pre><p>But it is not enough. The agent also needs to know:</p><pre>which product this applies to<br>when this policy was active<br>which policy replaced it<br>who approved the change<br>which customer cases were affected<br>whether the old policy should still be used</pre><p>That is relationship-heavy context.</p><p><strong>Cognee’s</strong> architecture maps well to this because it uses three complementary layers. The relational store tracks metadata and provenance. The vector store handles semantic search. The graph store captures entities and relationships.</p><p>So a messy policy update can become structured memory.</p><pre>Old policy → refund window → 30 days<br>New policy → refund window → 14 days<br>New policy → applies to → product line B<br>New policy → approved by → finance team<br>Old policy → replaced by → new policy<br>Old policy → should not be used for → new cases</pre><p>Now the agent has a better shot at understanding that the old policy is not just “another relevant memory.” It is a replaced memory. That distinction matters.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ackku-SqC69DtZmtJr7TBQ.png" /></figure><p>This is where Cognee feels different from a plain “chat with your docs” setup.</p><p>A document search tool may find both old and new policy docs. A vector search system may even rank both as relevant. But a memory layer with graph structure can help show how they relate.</p><p>➙ Old policy was replaced by new policy.<br>➙ Old workaround was superseded by official fix.<br>➙ Old runbook was updated after postmortem.<br>➙ Old customer preference was changed in a later conversation.</p><p>That is the difference between retrieving information and understanding memory state.</p><h3>5. Quick competitor landscape: not all memory tools solve the same problem</h3><p>This space is getting crowded fast, so I would not frame Cognee as “the only memory tool.” Different tools are solving different memory problems.</p><p>So here is the short version:</p><ul><li><strong>Mem0</strong> is strong around personalized long-term memory. It focuses on extracting, updating, and retrieving useful facts from conversations, and its research shows big latency and token-cost savings compared with full-context approaches.</li><li><strong>Zep and Graphiti </strong>focus heavily on temporal knowledge graphs. That makes them interesting when facts change over time and you need to reason about when something was true.</li><li><strong>LangGraph memory </strong>is useful if you are already building with LangGraph and want long-term memory stored as JSON documents under namespaces.</li><li><strong>Letta</strong>, originally MemGPT, is more about stateful agents with memory blocks and agent-managed memory behavior.</li></ul><p><strong>Cognee stands out because it is very aligned with turning unstructured data into graph-vector memory, while keeping provenance and structure in the loop.</strong></p><p>So the real question is not:</p><blockquote>Which memory tool is best?</blockquote><p>The better question is:</p><blockquote>What kind of forgetting problem are you trying to solve?</blockquote><ul><li>If your app needs user preference memory, Mem0 may be a good fit.</li><li>If your app needs temporal fact tracking, Graphiti or Zep may be worth studying closely.</li><li>If your app is already in LangGraph, LangGraph’s memory store may be enough.</li><li>If your problem is scattered documents, relationship-heavy context, and memory that needs structure, Cognee becomes very interesting.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S0H5tvAiDC_B0mxSENZipA.png" /></figure><p><strong>This is also why I think Cognee’s </strong><strong>forget and </strong><strong>improve ideas deserve more attention.</strong></p><p>Most people will thinkabout agents remembering, but only fewer people will think about agents needing memory cleanup.</p><h3>6. What I would build next</h3><p>If I were turning this idea into a real tool, I would build a memory hygiene layer for agents — a system that helps agents keep memory clean.</p><p>The first version would track four things:</p><pre>current facts<br>replaced facts<br>conflicting facts<br>stale facts</pre><p>The goal would be simple → before an agent uses a memory, it should check whether that memory is still safe to use.</p><p>For example:</p><pre>recall(&quot;refund policy for Product B&quot;)<br>check_if_replaced(memory)<br>check_if_conflicting(memory)<br>check_provenance(memory)<br>return_current_policy_only()</pre><p>Over time, this could work across product docs, support policies, runbooks, sales rules, customer preferences, compliance notes, and research files.</p><p>The agent would not just ask: <em>What do I remember?</em></p><p>It would ask: <em>Is this memory still true?</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aKskFNiWtADkON7GX7fIGg.png" /></figure><p>This is where <strong>Cognee</strong> could be a strong base, because it already treats memory as something that can be remembered, recalled, improved, and forgotten.</p><p>That gives developers a better starting point than a giant pile of vector chunks.</p><h3>Conclusion</h3><p>The first wave of agent memory talk is obvious → Agents should remember.</p><p>But the next wave is more important → Agents should remember carefully.</p><p>They need to know when a memory is useful, when it is stale, when it was replaced, and when it should be forgotten.</p><p>This is why <strong>Cognee</strong> is interesting because it points toward a more serious way of thinking about memory: structured, connected, improvable, and forgettable.</p><p>The future of AI agents will not be won by the ones that remember the most. It will be won by the ones that remember what still matters.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1332f6bb64f1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building Secure Smart Contracts with ‘Ownable’ in TON Blockchain]]></title>
            <link>https://medium.com/@vaishnavi180806/building-secure-smart-contracts-with-ownable-in-ton-blockchain-bec02adb6905?source=rss-2983f0f10f19------2</link>
            <guid isPermaLink="false">https://medium.com/p/bec02adb6905</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[web3]]></category>
            <category><![CDATA[ton]]></category>
            <category><![CDATA[smart-contracts]]></category>
            <dc:creator><![CDATA[Vaishnavi]]></dc:creator>
            <pubDate>Fri, 11 Apr 2025 05:17:18 GMT</pubDate>
            <atom:updated>2025-04-11T05:34:58.428Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tghV20PDlXA7pBS0HETfFQ.jpeg" /></figure><h4>Learn how to protect privileged actions using the Ownable trait in TACT Programming Language</h4><p>If you’ve ever wanted to peek behind the curtain of smart contracts built on the <strong>TON blockchain</strong>, this is your sign. In this blog, we’re diving deep into a simple yet powerful smart contract built using <strong>TACT</strong>, TON’s native programming language.</p><p>Whether you’re a Web3 newbie or a dev curious about TON, you’ll walk away with clarity, creativity, and maybe even a smart contract of your own.</p><h3>Getting started with Smart Contracts on TON</h3><p><strong>TON (The Open Network)</strong> is a fast and scalable layer-1 blockchain designed for mass adoption. Originally developed by Telegram, it’s now a community-driven project focused on high transaction speeds and user-friendly applications. TON boasts a unique multi-chain architecture for efficient processing and aims to seamlessly integrate blockchain technology with everyday internet users.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*d0RJb3qa-eU9VKnY.jpg" /><figcaption>Benefits and Advantages of TON Blockchain</figcaption></figure><p>Now, you must’ve heard of the term “smart contracts” often while hearing about blockchain or web3.</p><p>Well, a <strong>smart contract</strong> on a blockchain is a self-executing contract with the terms of the agreement directly written into code. This code is stored on a distributed, decentralized blockchain network and automatically executes when predetermined conditions are met and verified by the network.</p><blockquote>Smart contracts are like digital vending machines — you send them a coin (a transaction), and they deliver a service, no human involved. They’re secure, automatic, and live on blockchains.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*3LtfEZtwnIwIu7xF.jpg" /><figcaption>Working of a Smart Contract</figcaption></figure><h3>What is TACT?</h3><p><strong>Tact</strong> is a relatively new, statically-typed programming language specifically designed for writing smart contracts on the <strong>TON (The Open Network)</strong> blockchain. It aims to provide a more developer-friendly and efficient alternative to FunC, the original primary language for TON smart contracts.</p><p>Key characteristics of Tact include:</p><ul><li>It features a syntax that is familiar to developers with experience in TypeScript and JavaScript, making it easier to learn and adopt.</li><li>It is designed to produce efficient code that runs well on the TON Virtual Machine (TVM).</li><li>Creates more robust and secure smart contracts.</li><li>It aims to reduce boilerplate code, provide better tooling for smooth development.</li><li>It supports modular development via <strong>traits</strong>, like the one we’ll see soon — Ownable.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*q1V1fpDsznbKXouG.png" /></figure><blockquote>Think of TACT as the LEGO set designed specifically for TON. Each block (function, variable, trait) snaps together to build powerful dApps. Unlike lower-level languages, TACT is expressive and beginner-friendly, yet powerful under the hood.</blockquote><h3>Writing a TACT Smart Contract</h3><p>In this blog, we will be breaking down the “<strong>Ownable Contract</strong>” from <a href="https://tact-by-example.org/05-the-ownable-trait">TACT by Example</a> in a simplified manner.</p><p>Here’s what this contract can do:</p><ul><li>Anyone can <strong>increment</strong> a number (like pressing a public button).</li><li>Only the <strong>owner</strong> can <strong>double</strong> the number (like pressing a hidden admin button).</li><li>Anyone can <strong>query the current number and the owner address</strong>.</li></ul><p>Pretty simple, right? But under the hood, it packs powerful ideas like <strong>access control</strong>, <strong>stateful behavior</strong>, and <strong>event-based messaging</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ly0Xe3UqMwDBq9EO.gif" /></figure><h3>Code Overview</h3><p>This code is referred from “The Ownable Contract” from <a href="https://tact-by-example.org/05-the-ownable-trait">Tact by example.</a></p><pre>import &quot;@stdlib/ownable&quot;;<br>import &quot;@stdlib/deploy&quot;;<br><br>contract Counter with Deployable, Ownable {<br>    owner: Address;<br>    val: Int as uint32;<br><br>    init() {<br>        self.owner = sender();<br>        self.val = 0;<br>    }<br><br>    receive(&quot;increment&quot;) {<br>        self.val = self.val + 1;<br>    }<br><br>    receive(&quot;double&quot;) {<br>        self.requireOwner();<br>        self.val = self.val * 2;<br>    }<br><br>    get fun value(): Int {<br>        return self.val;<br>    }<br><br>    // get fun owner(): Address is added automatically<br>}</pre><p>Now let’s break it down:</p><h4><strong>1. Imports</strong></h4><pre>import &quot;@stdlib/ownable&quot;;<br>import &quot;@stdlib/deploy&quot;;</pre><p>These lines import prebuilt <strong>traits</strong> from TACT’s standard library.</p><ul><li>@stdlib/ownable: Adds ownership-related functionality to the contract. It provides the requireOwner() method and auto-generates a getter for the owner address. This trait expects the contract to define a state variable named owner: Address.</li><li>@stdlib/deploy: Enables the contract to be deployed via a special deployment message. It ensures the init() function runs correctly when the contract is first created.</li></ul><p><em>Traits in TACT are like mixins or modules — reusable blocks of logic that can be attached to a contract to add specific behavior.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*A6M9Kh7IitNROjm3.png" /><figcaption>This is similar to importing modules from parent directory</figcaption></figure><h4>2. Owner: the Contract’s Admin</h4><pre>owner: Address;<br>val: Int as uint32;</pre><p>Theval is a variable of type unsigned 32-bit integer.</p><p>The owner is like the VIP of this smart contract. This address is given special permissions — it can do things regular users can&#39;t. In this case, the owner has the power to <strong>double the counter</strong>, while everyone else can only increment it.</p><p>This is enabled by using the Ownable trait from TACT, which enforces this behavior using the function self.requireOwner().</p><blockquote>Imagine you’re building a smart lock system for a house. Multiple people can ring the doorbell (public function), but only the homeowner (owner address) can unlock or reconfigure the system.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UjN68y3Je9gmxpVcNnyTMw.png" /><figcaption>This contract is like a room with two buttons: Green Button (Anyone can press it to increase a counter by 1) and Red Button (Only the admin with a key can press it to double the number)</figcaption></figure><h4>3. The init() function</h4><pre>init() {<br>    self.owner = sender();<br>    self.val = 0;<br>}</pre><p>This is your contract’s birth moment. It’s where you define how things start:</p><ul><li>self.owner = sender();: The contract assigns the person who deployed it as the owner.</li><li>self.val = 0;: The counter is initialized at 0.</li><li>sender() refers to the message sender, and during deployment, it’s the wallet address that deploys the contract.</li></ul><blockquote>Think of this as, if you’re opening a café, this is the point where:<br>1. You put your name on the business license (owner),<br>2. Set the cash register to $0 (counter).<br>Now, your café is ready to serve customers — but you’re still the one who can change the recipe or reset the register.</blockquote><h4>4. Messages: Interacting with the Contract</h4><h4>I. increment — Open to All</h4><pre>receive(&quot;increment&quot;) {<br>    self.val = self.val + 1;<br>}</pre><p>Anyone can send a message labeled &quot;increment&quot;, and the contract will <strong>increase the </strong><strong>val counter by 1</strong>.</p><p>This is a <strong>permissionless</strong> action — no identity or access check is performed.</p><blockquote>Take an example: You build a public scoreboard. Anyone who visits can press a “+1” button. Every press increases the score — no authentication needed.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/637/0*qTFxKkySqnyTlSJS.gif" /><figcaption>“increment”is like a <em>“like” button</em> on a social post. Everyone can click it, and the number goes up.</figcaption></figure><h4>II. double — Owner-Only Action</h4><pre>receive(&quot;double&quot;) {<br>    self.requireOwner();<br>    self.val = self.val * 2;<br>}</pre><p>Before anything happens, this function runs:</p><pre>self.requireOwner();</pre><p>This is the <strong>bouncer</strong> at the door. If the sender isn’t the stored owner, the message is rejected and the transaction is reverted. This ensures <strong>only the owner</strong> can double the value.</p><blockquote>For Example: You run a donation matching program. Anyone can donate a dollar (increment), but only the admin can press a “Match Donations” button — which doubles the collected amount.</blockquote><figure><img alt="It’s like trying to access the admin panel of a website — unless you’re logged in as the admin, you’re shown the door." src="https://cdn-images-1.medium.com/max/800/0*0ATVrcWL7DbOPdz1.gif" /><figcaption>It’s like trying to access the admin panel of a website -&gt; unless you’re logged in as the admin, you’re shown the door.</figcaption></figure><h4>5. Getters: Read-Only Views</h4><pre>get fun value(): Int {<br>    return self.val;<br>}</pre><p>TACT allows you to expose read-only functions using get fun. These don’t cost gas and don’t change state — they’re pure queries. This getter simply returns the current value of the counter.</p><p>Because we used the Ownable trait, the following getter is <strong>automatically added</strong>:</p><pre>get fun owner(): Address</pre><p>So anyone can ask: <em>“Who owns this contract?”</em></p><blockquote>For Example, you build a public dashboard that shows: current donation count and Contract owner address.<br>Anyone can visit and read the values — no login required, no risks involved.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*GV94kpmFNxjn1TtW.gif" /><figcaption>This is like viewing someone’s Instagram profile — you can see their follower count and username, but you can’t change them unless you’re the account owner.</figcaption></figure><h3>Key Takeaways:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/839/1*9BEFGNpymOCqVuGXcVGTog.png" /><figcaption>The Ownable Contract: Key Features Summarized</figcaption></figure><h3>Why is this useful?</h3><p>This smart contract illustrates <strong>real-world essentials</strong> of blockchain development:</p><ul><li><strong>Public interaction</strong>: Letting users perform safe, limited actions (increment).</li><li><strong>Admin privileges</strong>: Restricting high-privilege actions (double) to one trusted party.</li><li><strong>Stateful data</strong>: The counter persists across messages — like saving to a database.</li><li><strong>Modular behavior</strong>: Traits like Ownable and Deployable abstract common patterns.</li></ul><h3>Real-World Use Cases</h3><ul><li>A <strong>token contract</strong> where only the creator can mint new tokens.</li><li>A <strong>voting contract</strong> where only admins can tally final results.</li><li>A <strong>game</strong> where users collect points (increment), but only the game master can multiply points during a bonus round (double).</li></ul><h3>Wrapping Up</h3><p>Smart contracts don’t always need to be complex to be powerful. This simple Counter contract shows how combining modular traits like Ownable and Deployable can give you both flexibility and control in your dApp logic — all while keeping your code readable and secure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*0u50mjFQJ4u2DrUiR0fAZQ.gif" /></figure><p>If you’re just getting started with <strong>TON blockchain</strong> and <strong>TACT</strong>, this is a great foundation to build on. You’ve now seen how ownership, message handling, and state management work in a real contract — with both public and privileged actions.</p><p>If you found this helpful, don’t forget to <strong>follow me</strong> here on Medium for more informational blogs.</p><p>Thanks for reading! <br>Until next time, happy building on TON!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*72X1BX9jsJcRrWO8sISxVg.gif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bec02adb6905" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>