Evidence

Evidence AI

Evidence AI

Evidence AI

Evidence AI

Evidence AI

Evidence AI

Evidence AI

Evidence AI

Evidence AI

Evidence AI

Thoughts on this ?

I got tired of seeing fly tipping near where I live so I started building an AI system to detect it. Computer vision, YOLOv8, trail cameras. 95% vehicle detection on first model. Building toward automatic alerts and evidence packaging for council prosecution. I’m 14 and doing this from my bedroom in Manchester. submitted by /u/NeuroDash [link] [comments]

One feature we removed from our prototype before writing a single line of code

​ One of the first ideas I had while planning our AI verification prototype was to add a confidence score to every result. The more I thought about it, the less I liked the idea. Imagine an AI says: "EBITDA = $12.3M (96% confidence)" What does 96% actually tell the person reviewing a borrower package? It doesn't explain: where the number came from, whether another document reports a different value, whether the calculation follows the covenant definition, or whether the evidence is complete. A high confidence score can easily become another thing people trust without understanding. So we removed it. Instead, we're experimenting with something much simpler: Every important financial claim should answer four questions: Where did this value come from? Can I open the source immediately? Does another document disagree? If it's calculated, can I reproduce the math? Maybe confidence scores are useful in some applications. For the kind of workflows we're exploring, I'd rather help someone verify an answer than persuade them to trust one. I'm curious how others think about this. If you're building AI products, do you expose confidence scores to users, or have you found better ways to communicate reliability? submitted by /u/MuhammadMujtaba21 [link] [comments]

Claude Code catastrophe: Entire project recursively deleted while prompting in Chinese (full video + logs)

Cross-posting from r/claude for more visibility. LAST UPDATE: I managed to recover the code later from an Electron packaged build / updater cache / app.asar. But the recovery is not the part that bothers me. My prompt did not ask for deletion. Not even close. Yet Claude Code generated the Windows equivalent of a recursive forced delete, basically “sudo rm -rf” behavior. This time, it stayed inside the project folder. But if this had not been a coding project, what would the scope have been? If the agent had chosen a parent folder, Documents, Desktop, or another writable path, what stops it? With a terminal agent, the blast radius is whatever path it chooses to operate on, limited by the permissions of that terminal session. From now on, I will treat Claude Code the same way I would treat OpenClaw: useful, but not trusted outside an isolated environment. And I think that should be the default assumption for any AI agent with terminal access. ------------------------------------------ Claude Code recursively wiped the contents of my local Electron project root. This happened in a Windows terminal while working on a project named Orpheus. My prompt did not ask it to delete, wipe, clean, reset, or remove the project. The prompt was in Traditional Chinese: “之前我要安裝檔，但是其實我只需要 dictate.” It was roughly about not needing the installer anymore and only needing the dictate function. The preserved terminal transcript later showed Claude moving from a failed root deletion attempt to deleting the child items inside the project root. The destructive sequence included: Get-ChildItem -LiteralPath $p -Force -ErrorAction SilentlyContinue | ForEach-Object { try { Remove-Item -LiteralPath $_.FullName -Recurse -Force -ErrorAction Stop "OK $($_.Name)" } catch { "ERR $($_.Name): $($_.Exception.Message)" } } $p was the Orpheus project root. The output then showed items being removed, including: .claude dist node_modules src claude-elevenlabs-voice-v2.user.js dictation.html main.js ORPHEUS_HANDOFF.md package-lock.json package.json preload.js Local artifacts I found for Orpheus showed default / acceptEdits. I did not find Orpheus bypassPermissions. I did not find Orpheus --dangerously-skip-permissions. I’m not claiming Anthropic acted maliciously. I’m not claiming prompt injection or anti-distillation without evidence. Moral of the story: Treat frontier AI agents like any other automation tool with real machine access. Back up regularly. Use a separate working copy or a different machine if you absolutely need an agent living in your terminal. A frontier model can still behave like a destructive script runner. I also generated SHA256 hashes for the preserved transcript and permission search output. EDIT / UPDATE: A few people asked about git. Yes, I know what git is. This was a local Electron prototype / working state that had not been pushed to a remote. Commits and backups are the right mitigation. But mitigation is not causation. The concerning part is that the destructive action was unrelated to my prompt. Claude Code was operating through a terminal session with real filesystem access under my user environment. Git may help recover a repo, but it does not protect everything else that same terminal session can access. My takeaway remains: Treat frontier terminal AI agents like real automation tools with destructive capability, not like chatbots. EDIT / UPDATE: Clarification because many comments are focusing on git: Yes, this specific local working state had not been pushed to a remote. That is on me. Lesson learned. But git is version control, not automatically a backup. If the only repo is local and the project root contents are recursively deleted, the local .git directory can be deleted too. Without a remote, separate clone, backup, or snapshot, local git alone is not enough. submitted by /u/OmegleAuthor [link] [comments]

What evidence should AI coding agents leave before saying “done”?

I’m the maker of Superloopy, a small MIT-licensed workflow layer for Codex and Claude Code. I built it around a problem I kept running into with coding agents: after a long task, the final answer often sounds confident, but the human still has to reconstruct what was actually checked. The pattern I’m trying is an evidence gate before the agent can call work done: - define acceptance criteria up front - route specialized work through skills/subagents when useful - run command-backed checks where possible - save logs, screenshots, review notes, research notes, or other artifacts under `.superloopy/evidence/` - separate deterministic checks from manual/visual judgment - finish with a report that points to the actual evidence The strongest part is the command-backed gate: if a criterion has a command, Superloopy re-runs it in-process at completion, so a stale or fabricated “passed” claim should not reach the final report. Manual/visual checks still need human review, but they are called out separately instead of being mixed into a blanket “done.” Repo: https://github.com/beefiker/superloopy For people using AI coding agents: what proof do you actually want before trusting “done”? Tests/lint are obvious, but I’m curious about screenshots, visual diffs, browser traces, security scans, design checklists, or explicit “manual judgment required” sections. submitted by /u/Simple_Somewhere7662 [link] [comments]

Why do we trust AI answers simply because they sound confident?

Over the last few months, I've been thinking about one question: Why do we trust AI answers simply because they sound confident? In many domains, that confidence is harmless. But in finance, a single incorrect number can influence lending decisions, covenant monitoring, portfolio reviews, or risk assessments. The problem isn't that AI makes mistakes. Humans do too. The problem is that today's AI systems rarely show why a financial claim should be trusted. That realization led me to start building AutoFlow. We're not building another chatbot or AI wrapper. We're building a Credit Evidence Engine that verifies eligible financial claims against source evidence, calculation rules, and document consistency. Our first prototype is intentionally narrow. It focuses on credit packages, borrower financial statements, covenant calculations, and exception detection. If two documents report different EBITDA values, the system shouldn't silently choose one. It should expose the contradiction. If a leverage ratio is calculated, it should be traceable back to the covenant definition and supporting evidence. I'm sharing this journey in public because I believe trust is earned through transparent decisions, honest limitations, and continuous learning—not confident marketing. I'm still in the prototype stage, and I expect many assumptions to be challenged. That's exactly why I'm building in public. Question for other founders: When you're building trust before you have customers or production case studies, what has mattered most in your experience—clear scope, technical proof, transparent progress, or something else? I'd genuinely like to learn from your experience. submitted by /u/MuhammadMujtaba21 [link] [comments]

I have created a Chrome extension that fact checks YouTube videos as you watch

UPDATE — July 5 Fact-checks now stick. Some of you may have noticed a good bubble pop once and then not come back when you rewound or rewatched a moment. Under the hood, the engine does a second, deeper verification pass in the background that enriches a verdict with more context and sources — but that enriched result wasn't always reachable on replay, so the bubble could vanish. Fixed: once any viewer's session verifies a claim, that verdict now reliably shows every time — for you on replay, and for everyone else who watches that video. The first person to hit a claim does the work; everybody after gets it instantly. Update July 4th. New features announcement time, extension and back-end just updated! Opinions now get archaeology, not a shrug. The previous lazy version of fact-checking dismissed rhetoric as "subjective." The new pipeline excavates it: when a pundit says something loaded, the bubble digs out the kernel of truth it's built on and names where the framing distorts — same method no matter who's talking or which direction the spin goes. Substantive opinions get routed through the full evidence pipeline now instead of being waved off. The engine got a history/econ/science backbone. Verdicts on charged topics (crime stats, immigration economics, climate, party politics, defense spending...) are now anchored to sources both sides of the aisle actually cite — government data, academic consensus, the numbers everyone accepts and then argues about. The goal: the bubble tells you what's measured, names what's genuinely contested, and never pretends the contested part is settled. Time awareness. The engine now anchors every "today/tomorrow/yesterday" to when the event happened. Live mode. Point it at a live stream — breaking news, a speech, a debate — and it fact-checks in real time. Also if applicable for the content, it seeks backward behind the scenes and pulls in the accumulated caption as far back as the beginning. This is so it has the full context awareness when you join something live in progress. All for FREE! If you find yourself hitting the freemium limits frequently a bubble will have a link to get 5x the usage with PLUS. Information on that is also at PopUpFactCheck.com .. I am not trying to push that here (and I don't know what the subreddit rules are around that). But if anyone does decide to do that, I can could use the testing feedback of how that process goes. Looking forward to your feedback on the updates deployed today! Hi, I have been working on this for many months now and I'd really be happy for people to try it out. It is a Chrome extension called "PopUpFactCheck". It is an AI powered video fact checker. With it, you fact check any YouTube video that has captions. And you can use it, for free! You turn captions on, and sit back and watch the video as bubbles appear on the right-hand side of the video with fact checks, information, background, and other context. Great for watching politicians, news, history, and just about any content on YouTube. Claude Code was a major tool in my development, and the AI that is used is GPT 5.5. In addition, there is an extensive waterfall of sources including the TheNewsAPI, various government and public health and other APIs, social, and web search powered by DDGS and Serper. It's free, and you don't have to bring your own API keys or anything. You simply install and use. I will be looking forward to your feedback. PopUpFact Check - Chrome Web Store PopUpFactCheck - Homepage submitted by /u/userpostingcontent [link] [comments]

A language model that runs on 5$ chip. Comes with 12 AI applications. No cloud, no internet. Universal installer + Open source Github + Huggingface available. Test it yourself.

We've been working on something slightly ridiculous. A language model for MCUs. After V1, Atome LM v2 (SuperESP) turns an ESP32 into a tiny AI appliance capable of running: • Voice commands • Motion recognition • Machine anomaly detection • Air-quality classification • Energy disaggregation • Occupancy sensing • Water leak detection • Predictive maintenance • Wearable activity recognition • Agriculture monitoring • Sound events • Tiny custom classifiers All offline. No Linux. No accelerator. No WiFi required. Everything was tested on a physical ESP32-WROOM-32. Current numbers: • ~27 KB runtime state • ~265 KB free heap remaining • Bit-for-bit reproducible decisions • Ed25519 signed models • Tamper-evident inference logs • CSV → Train → Flash workflow Before anyone asks: No, this is not ChatGPT on an ESP32. No, it's not magic. The idea is simple: Collect your sensor data. Export CSV. Train. Flash. Deploy. https://github.com/TilelliLab/atome-lm submitted by /u/themoroccanship [link] [comments]

28 point compliance checklist for shipping AI agents into enterprise environments

We keep getting the same question from teams trying to close enterprise deals. What do we actually need to pass a security review? So we compiled the checklist. 28 items across 6 categories, each mapped to at least one framework (EU AI Act, SOC 2 Type II, ISO 42001, or NIST AI RMF). Quick summary Logging (6 items) - log every prompt/response with timestamps, capture the full decision chain (not just input/output), retain for 6+ months, make logs tamper-evident. Most teams fail here first because compliance logging is different from developer logging. Access control (5 items) - auth on every endpoint, RBAC, scoped API keys, credential rotation, failed auth tracking. We still see unauthenticated agent endpoints in production more often than you'd think. Data handling (5 items) - classify what flows through your agent, scan outputs for secret leakage before they reach users, document your processing pipeline, handle data residency for EU customers. Security testing (5 items) - adversarial testing before every release, document methodology and results, maintain a vulnerability disclosure process, track dependencies, test MCP/tool integrations separately. Runtime protection (4 items) - input scanning on every message, anomaly detection, rate limiting, and a kill switch that gets you to zero traffic in under 60 seconds. Incident response (3 items) - AI-specific IR plan, severity levels for agent incidents, and actually practicing your response with tabletop exercises. For most early-stage products, items 1-11 and 17-18 unblock enterprise deals fastest. If SOC 2 is your priority, start with logging and access control. If targeting EU markets, focus on retention and adversarial testing documentation. submitted by /u/Still_Piglet9217 [link] [comments]

i analyzed 500+ companies job postings to see what new roles are emerging due to ai

i kept seeing doomer posts talking about how ai is going to take away all jobs. i believe in the opposite - ai is going to add more jobs in the long term than it cuts, and i kept seeing evidence of that now. there were job titles i'd come across that 2-3 years were much more niche. i got curious to map this out so i created a site to track this. i scraped various job boards and filtered out titles which have exploded since 2022 thanks to ai and if you go through the onboarding, it'll match you to roles you are eligible for. i don't want this post to just be a promo so here are the top 5 roles we are seeing break out. the number in brackets is the number of such jobs we are tracking ai trainer / data annotation (1,218) forward-deployed engineer (485) ai solutions eng / architect (316) agent (engineer/pm/research) (260) applied-ai engineer (169) if you're interested in checking out the site for more roles/jobs you can check it out here: https://alterwork.com/roles any feedback would be great, thanks submitted by /u/AppropriateHamster [link] [comments]

When there is no answer key for scientific discovery how do we verify an ai hypothesis

I have been thinking a lot about the actual limits of AI-driven scientific discovery, specifically how we evaluate models when they are proposing genuinely new hypotheses where no "answer key" exists. When we test LLMs on standard benchmarks, we have a clean dataset with known solutions. But if we task a frontier model with proposing a novel chemical compound for carbon capture, or finding an undocumented biological pathway, there is literally no ground truth in the literature. The immediate response is usually "just run the physical experiment." But wet-labs are incredibly slow and expensive. You can't synthesize thousands of candidate compounds blindly. This means the bottleneck for AI in science isn't our ability to generate hypotheses, it's our ability to verify them under absolute uncertainty. The traditional way to check model outputs is self-reflection or self-grading. But this is a dead-end for discovery. If you ask a model to double-check its own chemical structure, it has the exact same theoretical blind spots that generated it in the first place. It just agrees with itself louder. I was reading about a new multi-agent research engine called Apodex that launched earlier this month, and they rely heavily on this split. Instead of a single model doing the work, they use independent verifier agents that are completely blind to the generator's internal prompts. The verifier's job is to take the proposed hypothesis, re-derive the underlying physical logic from first principles, and find contradictions. Those contradictions are then fed back to the generator as constraints for a revision pass. Instead of a self-check, making verification a completely distinct, adversarial step is the only way to squeeze out actual science from these models. If we can't verify, we can't truly discover. If the AI doesn't have an isolated checker, then we are just generating highly plausible guesses. How are your teams handling this transition? When a model proposes a candidate solution in your research, what is your standard of evidence before you spend actual physical or computational resources to test it? submitted by /u/Glad_Ad217 [link] [comments]

Agent Profiles Make AI Runs Safer, More Focused and Reusable

I’ve been building Agent Profiles in Row-Bot around a simple idea: A personal AI agent should not run every task with the same tools, context, skills, workspace access, and approval rules. Research, review, development, automation, and delegation all need different runtime boundaries. Here is the architecture. submitted by /u/Acceptable-Object390 [link] [comments]

AutoFlow Research Initiative — Looking for Deep Technical Thinkers

AutoFlow Research Initiative — Looking for Deep Technical Thinkers Over the last several months, I've been exploring a question that sits at the intersection of AI, verification, trust, and decision systems: Can we build systems that independently verify claims produced by AI rather than simply generating answers? The original idea began with financial analysis. Consider a statement such as: "Company revenue grew 25% year-over-year." Today, most AI systems generate this claim, but they do not formally verify it. Our approach is different: Extract claims from documents, reports, or AI outputs. Gather supporting evidence. Apply mathematical and logical verification where possible. Identify inconsistencies and contradictions. Produce transparent reasoning rather than black-box conclusions. The first prototype is focused on finance because financial claims are structured, measurable, and often objectively verifiable. Examples include: Revenue growth calculations Financial ratio validation Cross-document consistency checks Balance sheet reconciliation Earnings statement verification As research progressed, we encountered deeper questions involving computability, trust, governance, formal verification, and adjudication. One realization is that not every claim can be mathematically proven. This raises a larger challenge: Where is the boundary between: Proven facts Verifiable claims Evidence-supported conclusions Human-style adjudication That question is becoming the foundation of our long-term research vision. Recent Milestones Accepted into NVIDIA Inception Access to NVIDIA startup resources and technical programs Building the architecture for our first verification-focused prototype Engaging with researchers and experienced engineers on verification and governance concepts Initial outreach to pre-seed investors and startup ecosystems Who I'm Looking For I'm interested in meeting people who enjoy difficult problems and are willing to challenge assumptions. Particularly: AI/ML researchers and engineers Formal verification and theorem-proving enthusiasts Distributed systems and orchestration experts C++ systems engineers Applied mathematicians Trust, governance, and decision-system researchers What You'll Receive For the right long-term collaborators: Significant technical ownership Direct influence on architecture and research direction Equity participation based on contribution and commitment Access to NVIDIA Inception resources available to the team Opportunity to help define a new category around AI trust and verification I'm not looking for people who simply agree with the vision. I'm looking for people who can find the flaws in it. If concepts such as verification, computability, trust, formal reasoning, governance, theorem proving, symbolic systems, or AI reliability interest you, I'd love to connect and exchange ideas. Feel free to comment or send a message. submitted by /u/MuhammadMujtaba21 [link] [comments]

What a model reads beforehand changes how it answers later - and you can see it in the hidden states

TL;DR: Gave Gemma a neutral-topic text to read before asking it about NATO. It refused. Gave it a different text (about LLMs hedging too much — also unrelated to NATO) and it answered in full detail. Tested this on the model's internal state directly — the two texts put it in measurably different "regions" before it generates a single token. Not a jailbreak, weights don't change. Full data/code in repo, looking for someone to break this.** The behavioral pattern was first observed in GPT, Claude and is what motivated this project. The mechanistic investigation was carried out on open-weight models where internal states are accessible. A Structured Text Changes Claude’s Responses to Unrelated Tasks: Behavioral Evidence in Claude and Hidden-State Evidence from Gemma-3-12B Hi Reddit, I am posting this as a preface to a larger set of experimental results and as a request for technical review. The observation that started this project came from repeated interactions with Claude. I noticed that when the model first read a long, structured, analytically dense text, its answers to later, otherwise ordinary questions sometimes changed substantially. The preceding text contained no jailbreak instruction, role-play request, prompt override, fabricated harmful demonstrations, or request to imitate its style. The model did not need to endorse the text. It only had to process it before moving on to the next task. Here, a “structured text” means a single, self-contained block of text presented before the downstream tasks. It should not be confused with a long conversation, accumulated chat history, or context drift caused by many conversational turns. By “before the answer begins,” I mean the hidden state after the model has processed the text and the downstream question, but before it has generated the first answer token. In the open-weight runs, the measured claim is that after reading the structured text, the model can occupy a different region of its residual-stream hidden-state space, and the first-token probability distribution is then computed from that state. The basic conversational demonstration is simple. First, the model receives a long text. It is asked what the text is about, which serves as a basic comprehension check. Then, without resetting the conversation, it receives ordinary questions or tasks that are not about the text. A control run follows the same sequence but begins with a neutral text. The downstream tasks remain identical. Because Claude is a closed model, I cannot inspect its internal activations. I therefore treat my Claude observations as behavioral motivation, not mechanistic evidence. To investigate the effect directly, I moved to open-weight models, primarily Gemma-3-12B-PT and Gemma-3-12B-IT, where I could measure hidden states, compare layers, construct target/control directions, and examine the next-token probability distribution before generation. I am posting this partly because the original observation occurred in Claude and may be relevant to Anthropic. I am not claiming to have demonstrated the same internal mechanism inside Claude. I am prepared to share the exact closed-model conversations privately with Anthropic researchers for independent evaluation. Main Result and Scope The main result is not simply that text influences model output. That is expected. The narrower observation is that reading one long, structured text rather than a neutral text can change how the same model approaches later tasks that are not about either text. This difference is visible behaviorally. In open-weight experiments, it is also accompanied by measurable separation of the model’s pre-output hidden states in late layers. In a fullbank experiment using multiple target texts, control texts, and questions, Gemma-3-12B entered distinguishable late-layer states before generating an answer. A direction constructed from the target/control difference generalized beyond the individual prompt examples used to construct it. The separation was stronger in the instruction-tuned model than in the corresponding base model. The instruction-tuned model also produced a substantially sharper next-token probability distribution. This suggests that instruction tuning is associated not only with a change in hidden-state geometry but also with a more decisive mapping from hidden states to output probabilities. I am not claiming that the experiment proves a universal alignment bypass, permanent modification of the model, or complete causal control of its behavior. The strongest supported conclusion is that the preceding text can produce a measurable temporary change in the internal state from which later work is processed. For clarity, fullbank, Grade 3, and Grade 4 are internal names for successive experimental series in this project. They are not standard benchmark names, established scientific grades, or claims about evidence quality. Fullbank denotes the larger multi-context, multi-question run; Gra

Why self-reflection ReAct loops fail on long-horizon tasks, and the AgentOS verification architecture we built to fix it.

Saw a great discussion earlier in this sub about the limits of self-reflection and whether a separate verifier agent is actually worth the compute overhead. It highlighted a huge flaw: Having an agent grade its own scratchpad almost guarantees rubber-stamping: it reflects on its work with the exact same blind spots that produced the error. Here's the architecture we built for the Apodex-1.0 Heavy-Duty Solver to get verification out of the reasoner's head entirely. The dominant approach right now is the ReAct paradigm—one agent in a think-act-observe loop inside a single context window. Empirically, these loops hit a hard ceiling after a few hundred steps: the context congests, parallel branches of inquiry contaminate one another, and self-reflection degrades. An agent reflecting on its own work has the same blind spots that caused the error in the first place. We call this "pseudo-correctness"—an answer that looks confident, passes basic checks, but is structurally flawed. Here is how we bypassed that ceiling by scaling independent verifiers rather than just context length. 1. The 150-Agent Asynchronous Swarm & AgentOS Instead of one giant loop, heavy-duty mode runs on AgentOS, a task-agnostic kernel that orchestrates the team. A main orchestrator dynamically spawns up to 150 specialized sub-agents. Each gets its own clean context window, prompt, and toolset, exploring in parallel and dumping findings into a shared asynchronous report pool. 2. Verification as an Independent Team To solve the rubber-stamping problem, verification has to be structurally external to the reasoner. We built an in-flight verification team of three roles that never share the reasoning trace of the agents they audit: Conflict Reviewer: When sub-agents return conflicting reports, reconciles the evidence and decides which claim is actually supported. Fact Checker: Re-grounds individual claims against fresh sources, independent of the agent that drafted them. Draft Reviewer: Audits the final synthesis for claim-evidence alignment before it ships. 3. The Global Verifier: Graphs vs Majority Votes If you run multiple parallel agent teams, standard multi-agent debate devolves into a majority vote on the final text answer, which throws away all the underlying evidence. Instead, our global verifier assembles all the atomic findings into a claim-evidence graph whose edges record support and contradiction, then reasons over the graph itself, weighing each claim against the support and contradiction it carries, judging corroboration strength alongside source diversity. Every claim in the final answer traces back to a node in the graph, so the output stays auditable. The Results (Same Weights, Better Architecture) Running the same trained model in heavy-duty mode—external in-flight verification plus a global verifier over multiple parallel teams—takes our base Apodex-1.0 from 75.5 to 90.3 on BrowseComp and from 28.3 to 46.7 on FrontierScience-Research, using the exact same weights. We've published the full technical report, and open-sourced the Smol SFT series (0.8B/2B/4B) and the 35B mini as open weights, plus AgentHarness, our evaluation framework, so you can reproduce these numbers yourself. Tell us where the verifier breaks down in your own loops. submitted by /u/ApodexAI [link] [comments]

A stateful deterministic substrate engine in native C.

https://www.youtube.com/watch?v=X90A9ZFtg6g I built a native C substrate engine that runs locally and persists/restores state deterministically. This short demo shows: - clearing the live state - mounting a small knowledge pack - exporting state to disk - restarting the process - restoring the same state with a matching digest In the demo, the restored state is 106 nodes / 72 relations. The current demo path does not require cloud services or GPU inference. It also supports abstention instead of forcing an answer on missing evidence. I’d value technical feedback on the deterministic snapshot model and abstention behavior. submitted by /u/Potato_Mug [link] [comments]